/*
 *
 *    Copyright (c) 2020-2021 Project CHIP Authors
 *    Copyright (c) 2019 Google LLC.
 *    Copyright (c) 2016-2017 Nest Labs, Inc.
 *    All rights reserved.
 *
 *    Licensed under the Apache License, Version 2.0 (the "License");
 *    you may not use this file except in compliance with the License.
 *    You may obtain a copy of the License at
 *
 *        http://www.apache.org/licenses/LICENSE-2.0
 *
 *    Unless required by applicable law or agreed to in writing, software
 *    distributed under the License is distributed on an "AS IS" BASIS,
 *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *    See the License for the specific language governing permissions and
 *    limitations under the License.
 */

/**
 *    @file
 *      This file contains definitions of test certificates used by various unit tests.
 *
 */

#include <credentials/CHIPCert.h>

#include "CHIPCert_test_vectors.h"

namespace chip {
namespace TestCerts {

using namespace chip::Credentials;
using namespace chip::ASN1;

// clang-format off
extern const uint8_t gTestCerts[] = {
    TestCert::kRoot01,
    TestCert::kRoot02,
    TestCert::kICA01,
    TestCert::kICA02,
    TestCert::kICA01_1,
    TestCert::kFWSign01,
    TestCert::kNode01_01,
    TestCert::kNode01_02,
    TestCert::kNode02_01,
    TestCert::kNode02_02,
    TestCert::kNode02_03,
    TestCert::kNode02_04,
    TestCert::kNode02_05,
    TestCert::kNode02_06,
    TestCert::kNode02_07,
};
// clang-format on

extern const size_t gNumTestCerts = sizeof(gTestCerts) / sizeof(gTestCerts[0]);

CHIP_ERROR GetTestCert(uint8_t certType, BitFlags<TestCertLoadFlags> certLoadFlags, ByteSpan & cert)
{
    CHIP_ERROR err;
    bool derForm = certLoadFlags.Has(TestCertLoadFlags::kDERForm);

#define SELECT_CERT(NAME)                                                                                                          \
    do                                                                                                                             \
    {                                                                                                                              \
        if (certType == TestCert::k##NAME)                                                                                         \
        {                                                                                                                          \
            if (derForm)                                                                                                           \
            {                                                                                                                      \
                cert = ByteSpan(sTestCert_##NAME##_DER, sTestCert_##NAME##_DER_Len);                                               \
            }                                                                                                                      \
            else                                                                                                                   \
            {                                                                                                                      \
                cert = ByteSpan(sTestCert_##NAME##_Chip, sTestCert_##NAME##_Chip_Len);                                             \
            }                                                                                                                      \
            ExitNow(err = CHIP_NO_ERROR);                                                                                          \
        }                                                                                                                          \
    } while (0)

    SELECT_CERT(Root01);
    SELECT_CERT(Root02);
    SELECT_CERT(ICA01);
    SELECT_CERT(ICA02);
    SELECT_CERT(ICA01_1);
    SELECT_CERT(FWSign01);
    SELECT_CERT(Node01_01);
    SELECT_CERT(Node01_02);
    SELECT_CERT(Node02_01);
    SELECT_CERT(Node02_02);
    SELECT_CERT(Node02_03);
    SELECT_CERT(Node02_04);
    SELECT_CERT(Node02_05);
    SELECT_CERT(Node02_06);
    SELECT_CERT(Node02_07);
#undef SELECT_CERT

    err = CHIP_ERROR_CA_CERT_NOT_FOUND;

exit:
    return err;
}

const char * GetTestCertName(uint8_t certType)
{
#define NAME_CERT(NAME)                                                                                                            \
    do                                                                                                                             \
    {                                                                                                                              \
        if (certType == TestCert::k##NAME)                                                                                         \
        {                                                                                                                          \
            return #NAME;                                                                                                          \
        }                                                                                                                          \
    } while (0)

    NAME_CERT(Root01);
    NAME_CERT(Root02);
    NAME_CERT(ICA01);
    NAME_CERT(ICA02);
    NAME_CERT(ICA01_1);
    NAME_CERT(FWSign01);
    NAME_CERT(Node01_01);
    NAME_CERT(Node01_02);
    NAME_CERT(Node02_01);
    NAME_CERT(Node02_02);
    NAME_CERT(Node02_03);
    NAME_CERT(Node02_04);
    NAME_CERT(Node02_05);
    NAME_CERT(Node02_06);
    NAME_CERT(Node02_07);

    return nullptr;
}

CHIP_ERROR GetTestCertPubkey(uint8_t certType, const uint8_t ** certPubkey, uint32_t & certPubkeyLen)
{
    CHIP_ERROR err;

#define SELECT_CERT(NAME)                                                                                                          \
    do                                                                                                                             \
    {                                                                                                                              \
        if (certType == TestCert::k##NAME)                                                                                         \
        {                                                                                                                          \
            *certPubkey   = sTestCert_##NAME##_PublicKey;                                                                          \
            certPubkeyLen = sTestCert_##NAME##_PublicKey_Len;                                                                      \
            ExitNow(err = CHIP_NO_ERROR);                                                                                          \
        }                                                                                                                          \
    } while (0)

    SELECT_CERT(Root01);
    SELECT_CERT(Root02);
    SELECT_CERT(ICA01);
    SELECT_CERT(ICA02);
    SELECT_CERT(ICA01_1);
    SELECT_CERT(FWSign01);
    SELECT_CERT(Node01_01);
    SELECT_CERT(Node01_02);
    SELECT_CERT(Node02_01);
    SELECT_CERT(Node02_02);
    SELECT_CERT(Node02_03);
    SELECT_CERT(Node02_04);
    SELECT_CERT(Node02_05);
    SELECT_CERT(Node02_06);
    SELECT_CERT(Node02_07);
#undef SELECT_CERT

    err = CHIP_ERROR_CA_CERT_NOT_FOUND;

exit:
    return err;
}

CHIP_ERROR LoadTestCert(ChipCertificateSet & certSet, uint8_t certType, BitFlags<TestCertLoadFlags> certLoadFlags,
                        BitFlags<CertDecodeFlags> decodeFlags)
{
    CHIP_ERROR err;
    ChipCertificateData * certData;
    ByteSpan cert;

    // Get the requested certificate data.
    err = GetTestCert(certType, certLoadFlags, cert);
    SuccessOrExit(err);

    // Load it into the certificate set.
    err = certSet.LoadCert(cert.data(), static_cast<uint32_t>(cert.size()), decodeFlags);
    SuccessOrExit(err);

    // Get loaded certificate data.
    certData = const_cast<ChipCertificateData *>(certSet.GetLastCert());
    VerifyOrExit(certData != nullptr, err = CHIP_ERROR_INVALID_ARGUMENT);

    // Apply load flags.
    if (certLoadFlags.Has(TestCertLoadFlags::kSuppressIsCA))
    {
        certData->mCertFlags.Clear(CertFlags::kIsCA);
    }
    if (certLoadFlags.Has(TestCertLoadFlags::kSuppressKeyUsage))
    {
        certData->mCertFlags.Clear(CertFlags::kExtPresent_KeyUsage);
    }
    if (certLoadFlags.Has(TestCertLoadFlags::kSuppressKeyCertSign))
    {
        certData->mKeyUsageFlags.Clear(KeyUsageFlags::kKeyCertSign);
    }
    if (certLoadFlags.Has(TestCertLoadFlags::kSetPathLenConstZero))
    {
        certData->mCertFlags.Set(CertFlags::kPathLenConstraintPresent);
        certData->mPathLenConstraint = 0;
    }

exit:
    return err;
}

// ------------------------------ TEST CERTIFICATES ----------------------------------------

/**************  Test Root01 Certificate  **************
Certificate:
    Data:
        Version: 3 (0x2)
        Serial Number: 6479173750095827996 (0x59eaa632947f541c)
        Signature Algorithm: ecdsa-with-SHA256
        Issuer: 1.3.6.1.4.1.37244.1.4 = CACACACA00000001
        Validity
            Not Before: Oct 15 14:23:43 2020 GMT
            Not After : Oct 15 14:23:42 2040 GMT
        Subject: 1.3.6.1.4.1.37244.1.4 = CACACACA00000001
        Subject Public Key Info:
            Public Key Algorithm: id-ecPublicKey
                Public-Key: (256 bit)
                pub:
                    04:13:53:a3:b3:ef:1d:a7:08:c4:90:80:48:01:4e:
                    40:7d:59:90:ce:22:bc:4e:b3:3e:9a:5a:cb:25:a8:
                    56:03:eb:a6:dc:d8:21:36:66:a4:e4:4f:5a:ca:13:
                    eb:76:7f:af:a7:dc:dd:dc:33:41:1f:82:a3:0b:54:
                    3d:d1:d2:4b:a8
                ASN1 OID: prime256v1
                NIST CURVE: P-256
        X509v3 extensions:
            X509v3 Basic Constraints: critical
                CA:TRUE
            X509v3 Key Usage: critical
                Certificate Sign, CRL Sign
            X509v3 Subject Key Identifier:
                13:AF:81:AB:37:37:4B:2E:D2:A9:64:9B:12:B7:A3:A4:28:7E:15:1D
            X509v3 Authority Key Identifier:
                keyid:13:AF:81:AB:37:37:4B:2E:D2:A9:64:9B:12:B7:A3:A4:28:7E:15:1D

    Signature Algorithm: ecdsa-with-SHA256
         30:45:02:20:45:81:64:46:6c:8f:19:5a:bc:0a:bb:7c:6c:b5:
         a2:7a:83:f4:1d:37:f8:d5:3b:ee:c5:20:ab:d2:a0:da:05:09:
         02:21:00:b8:a7:c2:5c:04:2e:30:cf:64:dc:30:fe:33:4e:12:
         00:19:66:4e:51:50:49:13:4f:57:81:23:84:44:fc:75:31

-----BEGIN CERTIFICATE-----
MIIBnTCCAUOgAwIBAgIIWeqmMpR/VBwwCgYIKoZIzj0EAwIwIjEgMB4GCisGAQQB
gqJ8AQQMEENBQ0FDQUNBMDAwMDAwMDEwHhcNMjAxMDE1MTQyMzQzWhcNNDAxMDE1
MTQyMzQyWjAiMSAwHgYKKwYBBAGConwBBAwQQ0FDQUNBQ0EwMDAwMDAwMTBZMBMG
ByqGSM49AgEGCCqGSM49AwEHA0IABBNTo7PvHacIxJCASAFOQH1ZkM4ivE6zPppa
yyWoVgPrptzYITZmpORPWsoT63Z/r6fc3dwzQR+CowtUPdHSS6ijYzBhMA8GA1Ud
EwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgEGMB0GA1UdDgQWBBQTr4GrNzdLLtKp
ZJsSt6OkKH4VHTAfBgNVHSMEGDAWgBQTr4GrNzdLLtKpZJsSt6OkKH4VHTAKBggq
hkjOPQQDAgNIADBFAiBFgWRGbI8ZWrwKu3xstaJ6g/QdN/jVO+7FIKvSoNoFCQIh
ALinwlwELjDPZNww/jNOEgAZZk5RUEkTT1eBI4RE/HUx
-----END CERTIFICATE-----

-----BEGIN EC PRIVATE KEY-----
MHcCAQEEIH1zW+/pFqHAygL4ypiB5CZjqq+aucQzsom+JnAQdXQaoAoGCCqGSM49
AwEHoUQDQgAEE1Ojs+8dpwjEkIBIAU5AfVmQziK8TrM+mlrLJahWA+um3NghNmak
5E9ayhPrdn+vp9zd3DNBH4KjC1Q90dJLqA==
-----END EC PRIVATE KEY-----
*/

extern const uint8_t sTestCert_Root01_Chip[] = {
    0x15, 0x30, 0x01, 0x08, 0x59, 0xea, 0xa6, 0x32, 0x94, 0x7f, 0x54, 0x1c, 0x24, 0x02, 0x01, 0x37, 0x03, 0x27, 0x14, 0x01, 0x00,
    0x00, 0x00, 0xca, 0xca, 0xca, 0xca, 0x18, 0x26, 0x04, 0xef, 0x17, 0x1b, 0x27, 0x26, 0x05, 0x6e, 0xb5, 0xb9, 0x4c, 0x37, 0x06,
    0x27, 0x14, 0x01, 0x00, 0x00, 0x00, 0xca, 0xca, 0xca, 0xca, 0x18, 0x24, 0x07, 0x01, 0x24, 0x08, 0x01, 0x30, 0x09, 0x41, 0x04,
    0x13, 0x53, 0xa3, 0xb3, 0xef, 0x1d, 0xa7, 0x08, 0xc4, 0x90, 0x80, 0x48, 0x01, 0x4e, 0x40, 0x7d, 0x59, 0x90, 0xce, 0x22, 0xbc,
    0x4e, 0xb3, 0x3e, 0x9a, 0x5a, 0xcb, 0x25, 0xa8, 0x56, 0x03, 0xeb, 0xa6, 0xdc, 0xd8, 0x21, 0x36, 0x66, 0xa4, 0xe4, 0x4f, 0x5a,
    0xca, 0x13, 0xeb, 0x76, 0x7f, 0xaf, 0xa7, 0xdc, 0xdd, 0xdc, 0x33, 0x41, 0x1f, 0x82, 0xa3, 0x0b, 0x54, 0x3d, 0xd1, 0xd2, 0x4b,
    0xa8, 0x37, 0x0a, 0x35, 0x01, 0x29, 0x01, 0x18, 0x24, 0x02, 0x60, 0x30, 0x04, 0x14, 0x13, 0xaf, 0x81, 0xab, 0x37, 0x37, 0x4b,
    0x2e, 0xd2, 0xa9, 0x64, 0x9b, 0x12, 0xb7, 0xa3, 0xa4, 0x28, 0x7e, 0x15, 0x1d, 0x30, 0x05, 0x14, 0x13, 0xaf, 0x81, 0xab, 0x37,
    0x37, 0x4b, 0x2e, 0xd2, 0xa9, 0x64, 0x9b, 0x12, 0xb7, 0xa3, 0xa4, 0x28, 0x7e, 0x15, 0x1d, 0x18, 0x30, 0x0b, 0x40, 0x45, 0x81,
    0x64, 0x46, 0x6c, 0x8f, 0x19, 0x5a, 0xbc, 0x0a, 0xbb, 0x7c, 0x6c, 0xb5, 0xa2, 0x7a, 0x83, 0xf4, 0x1d, 0x37, 0xf8, 0xd5, 0x3b,
    0xee, 0xc5, 0x20, 0xab, 0xd2, 0xa0, 0xda, 0x05, 0x09, 0xb8, 0xa7, 0xc2, 0x5c, 0x04, 0x2e, 0x30, 0xcf, 0x64, 0xdc, 0x30, 0xfe,
    0x33, 0x4e, 0x12, 0x00, 0x19, 0x66, 0x4e, 0x51, 0x50, 0x49, 0x13, 0x4f, 0x57, 0x81, 0x23, 0x84, 0x44, 0xfc, 0x75, 0x31, 0x18,
};

extern const uint32_t sTestCert_Root01_Chip_Len = sizeof(sTestCert_Root01_Chip);

extern const uint8_t sTestCert_Root01_DER[] = {
    0x30, 0x82, 0x01, 0x9d, 0x30, 0x82, 0x01, 0x43, 0xa0, 0x03, 0x02, 0x01, 0x02, 0x02, 0x08, 0x59, 0xea, 0xa6, 0x32, 0x94, 0x7f,
    0x54, 0x1c, 0x30, 0x0a, 0x06, 0x08, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x04, 0x03, 0x02, 0x30, 0x22, 0x31, 0x20, 0x30, 0x1e, 0x06,
    0x0a, 0x2b, 0x06, 0x01, 0x04, 0x01, 0x82, 0xa2, 0x7c, 0x01, 0x04, 0x0c, 0x10, 0x43, 0x41, 0x43, 0x41, 0x43, 0x41, 0x43, 0x41,
    0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x1e, 0x17, 0x0d, 0x32, 0x30, 0x31, 0x30, 0x31, 0x35, 0x31, 0x34, 0x32,
    0x33, 0x34, 0x33, 0x5a, 0x17, 0x0d, 0x34, 0x30, 0x31, 0x30, 0x31, 0x35, 0x31, 0x34, 0x32, 0x33, 0x34, 0x32, 0x5a, 0x30, 0x22,
    0x31, 0x20, 0x30, 0x1e, 0x06, 0x0a, 0x2b, 0x06, 0x01, 0x04, 0x01, 0x82, 0xa2, 0x7c, 0x01, 0x04, 0x0c, 0x10, 0x43, 0x41, 0x43,
    0x41, 0x43, 0x41, 0x43, 0x41, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x59, 0x30, 0x13, 0x06, 0x07, 0x2a, 0x86,
    0x48, 0xce, 0x3d, 0x02, 0x01, 0x06, 0x08, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x03, 0x01, 0x07, 0x03, 0x42, 0x00, 0x04, 0x13, 0x53,
    0xa3, 0xb3, 0xef, 0x1d, 0xa7, 0x08, 0xc4, 0x90, 0x80, 0x48, 0x01, 0x4e, 0x40, 0x7d, 0x59, 0x90, 0xce, 0x22, 0xbc, 0x4e, 0xb3,
    0x3e, 0x9a, 0x5a, 0xcb, 0x25, 0xa8, 0x56, 0x03, 0xeb, 0xa6, 0xdc, 0xd8, 0x21, 0x36, 0x66, 0xa4, 0xe4, 0x4f, 0x5a, 0xca, 0x13,
    0xeb, 0x76, 0x7f, 0xaf, 0xa7, 0xdc, 0xdd, 0xdc, 0x33, 0x41, 0x1f, 0x82, 0xa3, 0x0b, 0x54, 0x3d, 0xd1, 0xd2, 0x4b, 0xa8, 0xa3,
    0x63, 0x30, 0x61, 0x30, 0x0f, 0x06, 0x03, 0x55, 0x1d, 0x13, 0x01, 0x01, 0xff, 0x04, 0x05, 0x30, 0x03, 0x01, 0x01, 0xff, 0x30,
    0x0e, 0x06, 0x03, 0x55, 0x1d, 0x0f, 0x01, 0x01, 0xff, 0x04, 0x04, 0x03, 0x02, 0x01, 0x06, 0x30, 0x1d, 0x06, 0x03, 0x55, 0x1d,
    0x0e, 0x04, 0x16, 0x04, 0x14, 0x13, 0xaf, 0x81, 0xab, 0x37, 0x37, 0x4b, 0x2e, 0xd2, 0xa9, 0x64, 0x9b, 0x12, 0xb7, 0xa3, 0xa4,
    0x28, 0x7e, 0x15, 0x1d, 0x30, 0x1f, 0x06, 0x03, 0x55, 0x1d, 0x23, 0x04, 0x18, 0x30, 0x16, 0x80, 0x14, 0x13, 0xaf, 0x81, 0xab,
    0x37, 0x37, 0x4b, 0x2e, 0xd2, 0xa9, 0x64, 0x9b, 0x12, 0xb7, 0xa3, 0xa4, 0x28, 0x7e, 0x15, 0x1d, 0x30, 0x0a, 0x06, 0x08, 0x2a,
    0x86, 0x48, 0xce, 0x3d, 0x04, 0x03, 0x02, 0x03, 0x48, 0x00, 0x30, 0x45, 0x02, 0x20, 0x45, 0x81, 0x64, 0x46, 0x6c, 0x8f, 0x19,
    0x5a, 0xbc, 0x0a, 0xbb, 0x7c, 0x6c, 0xb5, 0xa2, 0x7a, 0x83, 0xf4, 0x1d, 0x37, 0xf8, 0xd5, 0x3b, 0xee, 0xc5, 0x20, 0xab, 0xd2,
    0xa0, 0xda, 0x05, 0x09, 0x02, 0x21, 0x00, 0xb8, 0xa7, 0xc2, 0x5c, 0x04, 0x2e, 0x30, 0xcf, 0x64, 0xdc, 0x30, 0xfe, 0x33, 0x4e,
    0x12, 0x00, 0x19, 0x66, 0x4e, 0x51, 0x50, 0x49, 0x13, 0x4f, 0x57, 0x81, 0x23, 0x84, 0x44, 0xfc, 0x75, 0x31,
};

extern const uint32_t sTestCert_Root01_DER_Len = sizeof(sTestCert_Root01_DER);

extern const uint8_t sTestCert_Root01_PublicKey[] = {
    0x04, 0x13, 0x53, 0xa3, 0xb3, 0xef, 0x1d, 0xa7, 0x08, 0xc4, 0x90, 0x80, 0x48, 0x01, 0x4e, 0x40, 0x7d,
    0x59, 0x90, 0xce, 0x22, 0xbc, 0x4e, 0xb3, 0x3e, 0x9a, 0x5a, 0xcb, 0x25, 0xa8, 0x56, 0x03, 0xeb, 0xa6,
    0xdc, 0xd8, 0x21, 0x36, 0x66, 0xa4, 0xe4, 0x4f, 0x5a, 0xca, 0x13, 0xeb, 0x76, 0x7f, 0xaf, 0xa7, 0xdc,
    0xdd, 0xdc, 0x33, 0x41, 0x1f, 0x82, 0xa3, 0x0b, 0x54, 0x3d, 0xd1, 0xd2, 0x4b, 0xa8,
};

extern const uint8_t sTestCert_Root01_PublicKey_Len = sizeof(sTestCert_Root01_PublicKey);

extern const uint8_t sTestCert_Root01_PrivateKey[] = {
    0x7d, 0x73, 0x5b, 0xef, 0xe9, 0x16, 0xa1, 0xc0, 0xca, 0x02, 0xf8, 0xca, 0x98, 0x81, 0xe4, 0x26,
    0x63, 0xaa, 0xaf, 0x9a, 0xb9, 0xc4, 0x33, 0xb2, 0x89, 0xbe, 0x26, 0x70, 0x10, 0x75, 0x74, 0x1a,
};

extern const uint8_t sTestCert_Root01_PrivateKey_Len = sizeof(sTestCert_Root01_PrivateKey);

extern const uint8_t sTestCert_Root01_SubjectKeyId[] = {
    0x13, 0xAF, 0x81, 0xAB, 0x37, 0x37, 0x4B, 0x2E, 0xD2, 0xA9, 0x64, 0x9B, 0x12, 0xB7, 0xA3, 0xA4, 0x28, 0x7E, 0x15, 0x1D,
};

extern const uint8_t sTestCert_Root01_SubjectKeyId_Len = sizeof(sTestCert_Root01_SubjectKeyId);

/**************  Test Root02 Certificate  **************
Certificate:
    Data:
        Version: 3 (0x2)
        Serial Number: 2782606924353714404 (0x269dce413ba538e4)
        Signature Algorithm: ecdsa-with-SHA256
        Issuer: 1.3.6.1.4.1.37244.1.4 = CACACACA00000002, 1.3.6.1.4.1.37244.1.5 = FAB000000000001D
        Validity
            Not Before: Oct 15 14:23:43 2020 GMT
            Not After : Oct 15 14:23:42 2040 GMT
        Subject: 1.3.6.1.4.1.37244.1.4 = CACACACA00000002, 1.3.6.1.4.1.37244.1.5 = FAB000000000001D
        Subject Public Key Info:
            Public Key Algorithm: id-ecPublicKey
                Public-Key: (256 bit)
                pub:
                    04:6e:96:30:68:98:89:f6:06:b2:54:4f:0e:00:21:
                    e4:be:70:36:0c:3f:77:d0:33:be:50:6d:bc:64:63:
                    81:0f:9a:7a:1c:ef:d2:ed:e1:d0:06:56:ee:07:63:
                    aa:c5:03:e8:b2:40:ac:76:32:0c:75:35:c8:7f:dc:
                    f3:91:d7:21:32
                ASN1 OID: prime256v1
                NIST CURVE: P-256
        X509v3 extensions:
            X509v3 Basic Constraints: critical
                CA:TRUE
            X509v3 Key Usage: critical
                Certificate Sign, CRL Sign
            X509v3 Subject Key Identifier:
                B2:1B:EA:40:AB:F2:AB:A9:56:F9:82:E1:DA:D2:B6:06:92:06:90:E0
            X509v3 Authority Key Identifier:
                keyid:B2:1B:EA:40:AB:F2:AB:A9:56:F9:82:E1:DA:D2:B6:06:92:06:90:E0

    Signature Algorithm: ecdsa-with-SHA256
         30:46:02:21:00:8d:03:79:ff:1d:68:ab:8e:d7:b3:26:60:90:
         97:77:50:07:a2:1f:28:49:71:89:a8:d8:7c:85:cd:2f:1a:79:
         78:02:21:00:c1:eb:69:da:21:f0:0b:23:6c:02:83:43:57:3a:
         a7:98:6f:de:21:4a:77:a4:4d:ea:7a:0f:03:20:f7:5d:b6:80

-----BEGIN CERTIFICATE-----
MIIB4jCCAYegAwIBAgIIJp3OQTulOOQwCgYIKoZIzj0EAwIwRDEgMB4GCisGAQQB
gqJ8AQQMEENBQ0FDQUNBMDAwMDAwMDIxIDAeBgorBgEEAYKifAEFDBBGQUIwMDAw
MDAwMDAwMDFEMB4XDTIwMTAxNTE0MjM0M1oXDTQwMTAxNTE0MjM0MlowRDEgMB4G
CisGAQQBgqJ8AQQMEENBQ0FDQUNBMDAwMDAwMDIxIDAeBgorBgEEAYKifAEFDBBG
QUIwMDAwMDAwMDAwMDFEMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEbpYwaJiJ
9gayVE8OACHkvnA2DD930DO+UG28ZGOBD5p6HO/S7eHQBlbuB2OqxQPoskCsdjIM
dTXIf9zzkdchMqNjMGEwDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAQYw
HQYDVR0OBBYEFLIb6kCr8qupVvmC4drStgaSBpDgMB8GA1UdIwQYMBaAFLIb6kCr
8qupVvmC4drStgaSBpDgMAoGCCqGSM49BAMCA0kAMEYCIQCNA3n/HWirjtezJmCQ
l3dQB6IfKElxiajYfIXNLxp5eAIhAMHradoh8AsjbAKDQ1c6p5hv3iFKd6RN6noP
AyD3XbaA
-----END CERTIFICATE-----

-----BEGIN EC PRIVATE KEY-----
MHcCAQEEIPZLkcRw3jaaTSEexd9ohQszl851s9gtPlaTqxwJdlUeoAoGCCqGSM49
AwEHoUQDQgAEbpYwaJiJ9gayVE8OACHkvnA2DD930DO+UG28ZGOBD5p6HO/S7eHQ
BlbuB2OqxQPoskCsdjIMdTXIf9zzkdchMg==
-----END EC PRIVATE KEY-----
*/

extern const uint8_t sTestCert_Root02_Chip[] = {
    0x15, 0x30, 0x01, 0x08, 0x26, 0x9d, 0xce, 0x41, 0x3b, 0xa5, 0x38, 0xe4, 0x24, 0x02, 0x01, 0x37, 0x03, 0x27, 0x14, 0x02, 0x00,
    0x00, 0x00, 0xca, 0xca, 0xca, 0xca, 0x27, 0x15, 0x1d, 0x00, 0x00, 0x00, 0x00, 0x00, 0xb0, 0xfa, 0x18, 0x26, 0x04, 0xef, 0x17,
    0x1b, 0x27, 0x26, 0x05, 0x6e, 0xb5, 0xb9, 0x4c, 0x37, 0x06, 0x27, 0x14, 0x02, 0x00, 0x00, 0x00, 0xca, 0xca, 0xca, 0xca, 0x27,
    0x15, 0x1d, 0x00, 0x00, 0x00, 0x00, 0x00, 0xb0, 0xfa, 0x18, 0x24, 0x07, 0x01, 0x24, 0x08, 0x01, 0x30, 0x09, 0x41, 0x04, 0x6e,
    0x96, 0x30, 0x68, 0x98, 0x89, 0xf6, 0x06, 0xb2, 0x54, 0x4f, 0x0e, 0x00, 0x21, 0xe4, 0xbe, 0x70, 0x36, 0x0c, 0x3f, 0x77, 0xd0,
    0x33, 0xbe, 0x50, 0x6d, 0xbc, 0x64, 0x63, 0x81, 0x0f, 0x9a, 0x7a, 0x1c, 0xef, 0xd2, 0xed, 0xe1, 0xd0, 0x06, 0x56, 0xee, 0x07,
    0x63, 0xaa, 0xc5, 0x03, 0xe8, 0xb2, 0x40, 0xac, 0x76, 0x32, 0x0c, 0x75, 0x35, 0xc8, 0x7f, 0xdc, 0xf3, 0x91, 0xd7, 0x21, 0x32,
    0x37, 0x0a, 0x35, 0x01, 0x29, 0x01, 0x18, 0x24, 0x02, 0x60, 0x30, 0x04, 0x14, 0xb2, 0x1b, 0xea, 0x40, 0xab, 0xf2, 0xab, 0xa9,
    0x56, 0xf9, 0x82, 0xe1, 0xda, 0xd2, 0xb6, 0x06, 0x92, 0x06, 0x90, 0xe0, 0x30, 0x05, 0x14, 0xb2, 0x1b, 0xea, 0x40, 0xab, 0xf2,
    0xab, 0xa9, 0x56, 0xf9, 0x82, 0xe1, 0xda, 0xd2, 0xb6, 0x06, 0x92, 0x06, 0x90, 0xe0, 0x18, 0x30, 0x0b, 0x40, 0x8d, 0x03, 0x79,
    0xff, 0x1d, 0x68, 0xab, 0x8e, 0xd7, 0xb3, 0x26, 0x60, 0x90, 0x97, 0x77, 0x50, 0x07, 0xa2, 0x1f, 0x28, 0x49, 0x71, 0x89, 0xa8,
    0xd8, 0x7c, 0x85, 0xcd, 0x2f, 0x1a, 0x79, 0x78, 0xc1, 0xeb, 0x69, 0xda, 0x21, 0xf0, 0x0b, 0x23, 0x6c, 0x02, 0x83, 0x43, 0x57,
    0x3a, 0xa7, 0x98, 0x6f, 0xde, 0x21, 0x4a, 0x77, 0xa4, 0x4d, 0xea, 0x7a, 0x0f, 0x03, 0x20, 0xf7, 0x5d, 0xb6, 0x80, 0x18,
};

extern const uint32_t sTestCert_Root02_Chip_Len = sizeof(sTestCert_Root02_Chip);

extern const uint8_t sTestCert_Root02_DER[] = {
    0x30, 0x82, 0x01, 0xe2, 0x30, 0x82, 0x01, 0x87, 0xa0, 0x03, 0x02, 0x01, 0x02, 0x02, 0x08, 0x26, 0x9d, 0xce, 0x41, 0x3b, 0xa5,
    0x38, 0xe4, 0x30, 0x0a, 0x06, 0x08, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x04, 0x03, 0x02, 0x30, 0x44, 0x31, 0x20, 0x30, 0x1e, 0x06,
    0x0a, 0x2b, 0x06, 0x01, 0x04, 0x01, 0x82, 0xa2, 0x7c, 0x01, 0x04, 0x0c, 0x10, 0x43, 0x41, 0x43, 0x41, 0x43, 0x41, 0x43, 0x41,
    0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x31, 0x20, 0x30, 0x1e, 0x06, 0x0a, 0x2b, 0x06, 0x01, 0x04, 0x01, 0x82, 0xa2,
    0x7c, 0x01, 0x05, 0x0c, 0x10, 0x46, 0x41, 0x42, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x44,
    0x30, 0x1e, 0x17, 0x0d, 0x32, 0x30, 0x31, 0x30, 0x31, 0x35, 0x31, 0x34, 0x32, 0x33, 0x34, 0x33, 0x5a, 0x17, 0x0d, 0x34, 0x30,
    0x31, 0x30, 0x31, 0x35, 0x31, 0x34, 0x32, 0x33, 0x34, 0x32, 0x5a, 0x30, 0x44, 0x31, 0x20, 0x30, 0x1e, 0x06, 0x0a, 0x2b, 0x06,
    0x01, 0x04, 0x01, 0x82, 0xa2, 0x7c, 0x01, 0x04, 0x0c, 0x10, 0x43, 0x41, 0x43, 0x41, 0x43, 0x41, 0x43, 0x41, 0x30, 0x30, 0x30,
    0x30, 0x30, 0x30, 0x30, 0x32, 0x31, 0x20, 0x30, 0x1e, 0x06, 0x0a, 0x2b, 0x06, 0x01, 0x04, 0x01, 0x82, 0xa2, 0x7c, 0x01, 0x05,
    0x0c, 0x10, 0x46, 0x41, 0x42, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x44, 0x30, 0x59, 0x30,
    0x13, 0x06, 0x07, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x02, 0x01, 0x06, 0x08, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x03, 0x01, 0x07, 0x03,
    0x42, 0x00, 0x04, 0x6e, 0x96, 0x30, 0x68, 0x98, 0x89, 0xf6, 0x06, 0xb2, 0x54, 0x4f, 0x0e, 0x00, 0x21, 0xe4, 0xbe, 0x70, 0x36,
    0x0c, 0x3f, 0x77, 0xd0, 0x33, 0xbe, 0x50, 0x6d, 0xbc, 0x64, 0x63, 0x81, 0x0f, 0x9a, 0x7a, 0x1c, 0xef, 0xd2, 0xed, 0xe1, 0xd0,
    0x06, 0x56, 0xee, 0x07, 0x63, 0xaa, 0xc5, 0x03, 0xe8, 0xb2, 0x40, 0xac, 0x76, 0x32, 0x0c, 0x75, 0x35, 0xc8, 0x7f, 0xdc, 0xf3,
    0x91, 0xd7, 0x21, 0x32, 0xa3, 0x63, 0x30, 0x61, 0x30, 0x0f, 0x06, 0x03, 0x55, 0x1d, 0x13, 0x01, 0x01, 0xff, 0x04, 0x05, 0x30,
    0x03, 0x01, 0x01, 0xff, 0x30, 0x0e, 0x06, 0x03, 0x55, 0x1d, 0x0f, 0x01, 0x01, 0xff, 0x04, 0x04, 0x03, 0x02, 0x01, 0x06, 0x30,
    0x1d, 0x06, 0x03, 0x55, 0x1d, 0x0e, 0x04, 0x16, 0x04, 0x14, 0xb2, 0x1b, 0xea, 0x40, 0xab, 0xf2, 0xab, 0xa9, 0x56, 0xf9, 0x82,
    0xe1, 0xda, 0xd2, 0xb6, 0x06, 0x92, 0x06, 0x90, 0xe0, 0x30, 0x1f, 0x06, 0x03, 0x55, 0x1d, 0x23, 0x04, 0x18, 0x30, 0x16, 0x80,
    0x14, 0xb2, 0x1b, 0xea, 0x40, 0xab, 0xf2, 0xab, 0xa9, 0x56, 0xf9, 0x82, 0xe1, 0xda, 0xd2, 0xb6, 0x06, 0x92, 0x06, 0x90, 0xe0,
    0x30, 0x0a, 0x06, 0x08, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x04, 0x03, 0x02, 0x03, 0x49, 0x00, 0x30, 0x46, 0x02, 0x21, 0x00, 0x8d,
    0x03, 0x79, 0xff, 0x1d, 0x68, 0xab, 0x8e, 0xd7, 0xb3, 0x26, 0x60, 0x90, 0x97, 0x77, 0x50, 0x07, 0xa2, 0x1f, 0x28, 0x49, 0x71,
    0x89, 0xa8, 0xd8, 0x7c, 0x85, 0xcd, 0x2f, 0x1a, 0x79, 0x78, 0x02, 0x21, 0x00, 0xc1, 0xeb, 0x69, 0xda, 0x21, 0xf0, 0x0b, 0x23,
    0x6c, 0x02, 0x83, 0x43, 0x57, 0x3a, 0xa7, 0x98, 0x6f, 0xde, 0x21, 0x4a, 0x77, 0xa4, 0x4d, 0xea, 0x7a, 0x0f, 0x03, 0x20, 0xf7,
    0x5d, 0xb6, 0x80,
};

extern const uint32_t sTestCert_Root02_DER_Len = sizeof(sTestCert_Root02_DER);

extern const uint8_t sTestCert_Root02_PublicKey[] = {
    0x04, 0x6e, 0x96, 0x30, 0x68, 0x98, 0x89, 0xf6, 0x06, 0xb2, 0x54, 0x4f, 0x0e, 0x00, 0x21, 0xe4, 0xbe,
    0x70, 0x36, 0x0c, 0x3f, 0x77, 0xd0, 0x33, 0xbe, 0x50, 0x6d, 0xbc, 0x64, 0x63, 0x81, 0x0f, 0x9a, 0x7a,
    0x1c, 0xef, 0xd2, 0xed, 0xe1, 0xd0, 0x06, 0x56, 0xee, 0x07, 0x63, 0xaa, 0xc5, 0x03, 0xe8, 0xb2, 0x40,
    0xac, 0x76, 0x32, 0x0c, 0x75, 0x35, 0xc8, 0x7f, 0xdc, 0xf3, 0x91, 0xd7, 0x21, 0x32,
};

extern const uint8_t sTestCert_Root02_PublicKey_Len = sizeof(sTestCert_Root02_PublicKey);

extern const uint8_t sTestCert_Root02_PrivateKey[] = {
    0xf6, 0x4b, 0x91, 0xc4, 0x70, 0xde, 0x36, 0x9a, 0x4d, 0x21, 0x1e, 0xc5, 0xdf, 0x68, 0x85, 0x0b,
    0x33, 0x97, 0xce, 0x75, 0xb3, 0xd8, 0x2d, 0x3e, 0x56, 0x93, 0xab, 0x1c, 0x09, 0x76, 0x55, 0x1e,
};

extern const uint8_t sTestCert_Root02_PrivateKey_Len = sizeof(sTestCert_Root02_PrivateKey);

extern const uint8_t sTestCert_Root02_SubjectKeyId[] = {
    0xB2, 0x1B, 0xEA, 0x40, 0xAB, 0xF2, 0xAB, 0xA9, 0x56, 0xF9, 0x82, 0xE1, 0xDA, 0xD2, 0xB6, 0x06, 0x92, 0x06, 0x90, 0xE0,
};

extern const uint8_t sTestCert_Root02_SubjectKeyId_Len = sizeof(sTestCert_Root02_SubjectKeyId);

/**************  Test ICA01 Certificate  **************
Certificate:
    Data:
        Version: 3 (0x2)
        Serial Number: 3293332566983159519 (0x2db444855641aedf)
        Signature Algorithm: ecdsa-with-SHA256
        Issuer: 1.3.6.1.4.1.37244.1.4 = CACACACA00000001
        Validity
            Not Before: Oct 15 14:23:43 2020 GMT
            Not After : Oct 15 14:23:42 2040 GMT
        Subject: 1.3.6.1.4.1.37244.1.3 = CACACACA00000003
        Subject Public Key Info:
            Public Key Algorithm: id-ecPublicKey
                Public-Key: (256 bit)
                pub:
                    04:c5:d0:86:1b:b8:f9:0c:40:5c:12:31:4e:4c:5e:
                    be:ea:93:9f:72:77:4b:cc:33:23:9e:2f:59:f6:f4:
                    6a:f8:dc:7d:46:82:a0:e3:cc:c6:46:e6:df:29:ea:
                    86:bf:56:2a:e7:20:a8:98:33:7d:38:3f:32:c0:a0:
                    9e:41:60:19:ea
                ASN1 OID: prime256v1
                NIST CURVE: P-256
        X509v3 extensions:
            X509v3 Basic Constraints: critical
                CA:TRUE
            X509v3 Key Usage: critical
                Certificate Sign, CRL Sign
            X509v3 Subject Key Identifier:
                53:52:D7:05:9E:9C:15:A5:08:90:68:62:86:48:01:A2:9F:1F:41:D3
            X509v3 Authority Key Identifier:
                keyid:13:AF:81:AB:37:37:4B:2E:D2:A9:64:9B:12:B7:A3:A4:28:7E:15:1D

    Signature Algorithm: ecdsa-with-SHA256
         30:45:02:21:00:84:1a:06:d4:3b:5e:9f:ec:d2:4e:87:b1:24:
         4e:b5:1c:6a:2c:f2:0d:9b:5e:6b:a0:7f:11:e6:00:2f:7e:0c:
         a3:02:20:4e:32:a6:02:c3:60:9d:00:92:d3:48:bd:bd:19:8a:
         11:46:46:bd:41:cf:10:37:83:64:1a:e2:5e:3f:23:fd:26

-----BEGIN CERTIFICATE-----
MIIBnTCCAUOgAwIBAgIILbREhVZBrt8wCgYIKoZIzj0EAwIwIjEgMB4GCisGAQQB
gqJ8AQQMEENBQ0FDQUNBMDAwMDAwMDEwHhcNMjAxMDE1MTQyMzQzWhcNNDAxMDE1
MTQyMzQyWjAiMSAwHgYKKwYBBAGConwBAwwQQ0FDQUNBQ0EwMDAwMDAwMzBZMBMG
ByqGSM49AgEGCCqGSM49AwEHA0IABMXQhhu4+QxAXBIxTkxevuqTn3J3S8wzI54v
Wfb0avjcfUaCoOPMxkbm3ynqhr9WKucgqJgzfTg/MsCgnkFgGeqjYzBhMA8GA1Ud
EwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgEGMB0GA1UdDgQWBBRTUtcFnpwVpQiQ
aGKGSAGinx9B0zAfBgNVHSMEGDAWgBQTr4GrNzdLLtKpZJsSt6OkKH4VHTAKBggq
hkjOPQQDAgNIADBFAiEAhBoG1Dten+zSToexJE61HGos8g2bXmugfxHmAC9+DKMC
IE4ypgLDYJ0AktNIvb0ZihFGRr1BzxA3g2Qa4l4/I/0m
-----END CERTIFICATE-----

-----BEGIN EC PRIVATE KEY-----
MHcCAQEEIBGEO9zwrSBtsQJRpU2sWB11+ZL8tSJ1KiFs15xxdUapoAoGCCqGSM49
AwEHoUQDQgAExdCGG7j5DEBcEjFOTF6+6pOfcndLzDMjni9Z9vRq+Nx9RoKg48zG
RubfKeqGv1Yq5yComDN9OD8ywKCeQWAZ6g==
-----END EC PRIVATE KEY-----
*/

extern const uint8_t sTestCert_ICA01_Chip[] = {
    0x15, 0x30, 0x01, 0x08, 0x2d, 0xb4, 0x44, 0x85, 0x56, 0x41, 0xae, 0xdf, 0x24, 0x02, 0x01, 0x37, 0x03, 0x27, 0x14, 0x01, 0x00,
    0x00, 0x00, 0xca, 0xca, 0xca, 0xca, 0x18, 0x26, 0x04, 0xef, 0x17, 0x1b, 0x27, 0x26, 0x05, 0x6e, 0xb5, 0xb9, 0x4c, 0x37, 0x06,
    0x27, 0x13, 0x03, 0x00, 0x00, 0x00, 0xca, 0xca, 0xca, 0xca, 0x18, 0x24, 0x07, 0x01, 0x24, 0x08, 0x01, 0x30, 0x09, 0x41, 0x04,
    0xc5, 0xd0, 0x86, 0x1b, 0xb8, 0xf9, 0x0c, 0x40, 0x5c, 0x12, 0x31, 0x4e, 0x4c, 0x5e, 0xbe, 0xea, 0x93, 0x9f, 0x72, 0x77, 0x4b,
    0xcc, 0x33, 0x23, 0x9e, 0x2f, 0x59, 0xf6, 0xf4, 0x6a, 0xf8, 0xdc, 0x7d, 0x46, 0x82, 0xa0, 0xe3, 0xcc, 0xc6, 0x46, 0xe6, 0xdf,
    0x29, 0xea, 0x86, 0xbf, 0x56, 0x2a, 0xe7, 0x20, 0xa8, 0x98, 0x33, 0x7d, 0x38, 0x3f, 0x32, 0xc0, 0xa0, 0x9e, 0x41, 0x60, 0x19,
    0xea, 0x37, 0x0a, 0x35, 0x01, 0x29, 0x01, 0x18, 0x24, 0x02, 0x60, 0x30, 0x04, 0x14, 0x53, 0x52, 0xd7, 0x05, 0x9e, 0x9c, 0x15,
    0xa5, 0x08, 0x90, 0x68, 0x62, 0x86, 0x48, 0x01, 0xa2, 0x9f, 0x1f, 0x41, 0xd3, 0x30, 0x05, 0x14, 0x13, 0xaf, 0x81, 0xab, 0x37,
    0x37, 0x4b, 0x2e, 0xd2, 0xa9, 0x64, 0x9b, 0x12, 0xb7, 0xa3, 0xa4, 0x28, 0x7e, 0x15, 0x1d, 0x18, 0x30, 0x0b, 0x40, 0x84, 0x1a,
    0x06, 0xd4, 0x3b, 0x5e, 0x9f, 0xec, 0xd2, 0x4e, 0x87, 0xb1, 0x24, 0x4e, 0xb5, 0x1c, 0x6a, 0x2c, 0xf2, 0x0d, 0x9b, 0x5e, 0x6b,
    0xa0, 0x7f, 0x11, 0xe6, 0x00, 0x2f, 0x7e, 0x0c, 0xa3, 0x4e, 0x32, 0xa6, 0x02, 0xc3, 0x60, 0x9d, 0x00, 0x92, 0xd3, 0x48, 0xbd,
    0xbd, 0x19, 0x8a, 0x11, 0x46, 0x46, 0xbd, 0x41, 0xcf, 0x10, 0x37, 0x83, 0x64, 0x1a, 0xe2, 0x5e, 0x3f, 0x23, 0xfd, 0x26, 0x18,
};

extern const uint32_t sTestCert_ICA01_Chip_Len = sizeof(sTestCert_ICA01_Chip);

extern const uint8_t sTestCert_ICA01_DER[] = {
    0x30, 0x82, 0x01, 0x9d, 0x30, 0x82, 0x01, 0x43, 0xa0, 0x03, 0x02, 0x01, 0x02, 0x02, 0x08, 0x2d, 0xb4, 0x44, 0x85, 0x56, 0x41,
    0xae, 0xdf, 0x30, 0x0a, 0x06, 0x08, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x04, 0x03, 0x02, 0x30, 0x22, 0x31, 0x20, 0x30, 0x1e, 0x06,
    0x0a, 0x2b, 0x06, 0x01, 0x04, 0x01, 0x82, 0xa2, 0x7c, 0x01, 0x04, 0x0c, 0x10, 0x43, 0x41, 0x43, 0x41, 0x43, 0x41, 0x43, 0x41,
    0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x1e, 0x17, 0x0d, 0x32, 0x30, 0x31, 0x30, 0x31, 0x35, 0x31, 0x34, 0x32,
    0x33, 0x34, 0x33, 0x5a, 0x17, 0x0d, 0x34, 0x30, 0x31, 0x30, 0x31, 0x35, 0x31, 0x34, 0x32, 0x33, 0x34, 0x32, 0x5a, 0x30, 0x22,
    0x31, 0x20, 0x30, 0x1e, 0x06, 0x0a, 0x2b, 0x06, 0x01, 0x04, 0x01, 0x82, 0xa2, 0x7c, 0x01, 0x03, 0x0c, 0x10, 0x43, 0x41, 0x43,
    0x41, 0x43, 0x41, 0x43, 0x41, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x59, 0x30, 0x13, 0x06, 0x07, 0x2a, 0x86,
    0x48, 0xce, 0x3d, 0x02, 0x01, 0x06, 0x08, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x03, 0x01, 0x07, 0x03, 0x42, 0x00, 0x04, 0xc5, 0xd0,
    0x86, 0x1b, 0xb8, 0xf9, 0x0c, 0x40, 0x5c, 0x12, 0x31, 0x4e, 0x4c, 0x5e, 0xbe, 0xea, 0x93, 0x9f, 0x72, 0x77, 0x4b, 0xcc, 0x33,
    0x23, 0x9e, 0x2f, 0x59, 0xf6, 0xf4, 0x6a, 0xf8, 0xdc, 0x7d, 0x46, 0x82, 0xa0, 0xe3, 0xcc, 0xc6, 0x46, 0xe6, 0xdf, 0x29, 0xea,
    0x86, 0xbf, 0x56, 0x2a, 0xe7, 0x20, 0xa8, 0x98, 0x33, 0x7d, 0x38, 0x3f, 0x32, 0xc0, 0xa0, 0x9e, 0x41, 0x60, 0x19, 0xea, 0xa3,
    0x63, 0x30, 0x61, 0x30, 0x0f, 0x06, 0x03, 0x55, 0x1d, 0x13, 0x01, 0x01, 0xff, 0x04, 0x05, 0x30, 0x03, 0x01, 0x01, 0xff, 0x30,
    0x0e, 0x06, 0x03, 0x55, 0x1d, 0x0f, 0x01, 0x01, 0xff, 0x04, 0x04, 0x03, 0x02, 0x01, 0x06, 0x30, 0x1d, 0x06, 0x03, 0x55, 0x1d,
    0x0e, 0x04, 0x16, 0x04, 0x14, 0x53, 0x52, 0xd7, 0x05, 0x9e, 0x9c, 0x15, 0xa5, 0x08, 0x90, 0x68, 0x62, 0x86, 0x48, 0x01, 0xa2,
    0x9f, 0x1f, 0x41, 0xd3, 0x30, 0x1f, 0x06, 0x03, 0x55, 0x1d, 0x23, 0x04, 0x18, 0x30, 0x16, 0x80, 0x14, 0x13, 0xaf, 0x81, 0xab,
    0x37, 0x37, 0x4b, 0x2e, 0xd2, 0xa9, 0x64, 0x9b, 0x12, 0xb7, 0xa3, 0xa4, 0x28, 0x7e, 0x15, 0x1d, 0x30, 0x0a, 0x06, 0x08, 0x2a,
    0x86, 0x48, 0xce, 0x3d, 0x04, 0x03, 0x02, 0x03, 0x48, 0x00, 0x30, 0x45, 0x02, 0x21, 0x00, 0x84, 0x1a, 0x06, 0xd4, 0x3b, 0x5e,
    0x9f, 0xec, 0xd2, 0x4e, 0x87, 0xb1, 0x24, 0x4e, 0xb5, 0x1c, 0x6a, 0x2c, 0xf2, 0x0d, 0x9b, 0x5e, 0x6b, 0xa0, 0x7f, 0x11, 0xe6,
    0x00, 0x2f, 0x7e, 0x0c, 0xa3, 0x02, 0x20, 0x4e, 0x32, 0xa6, 0x02, 0xc3, 0x60, 0x9d, 0x00, 0x92, 0xd3, 0x48, 0xbd, 0xbd, 0x19,
    0x8a, 0x11, 0x46, 0x46, 0xbd, 0x41, 0xcf, 0x10, 0x37, 0x83, 0x64, 0x1a, 0xe2, 0x5e, 0x3f, 0x23, 0xfd, 0x26,
};

extern const uint32_t sTestCert_ICA01_DER_Len = sizeof(sTestCert_ICA01_DER);

extern const uint8_t sTestCert_ICA01_PublicKey[] = {
    0x04, 0xc5, 0xd0, 0x86, 0x1b, 0xb8, 0xf9, 0x0c, 0x40, 0x5c, 0x12, 0x31, 0x4e, 0x4c, 0x5e, 0xbe, 0xea,
    0x93, 0x9f, 0x72, 0x77, 0x4b, 0xcc, 0x33, 0x23, 0x9e, 0x2f, 0x59, 0xf6, 0xf4, 0x6a, 0xf8, 0xdc, 0x7d,
    0x46, 0x82, 0xa0, 0xe3, 0xcc, 0xc6, 0x46, 0xe6, 0xdf, 0x29, 0xea, 0x86, 0xbf, 0x56, 0x2a, 0xe7, 0x20,
    0xa8, 0x98, 0x33, 0x7d, 0x38, 0x3f, 0x32, 0xc0, 0xa0, 0x9e, 0x41, 0x60, 0x19, 0xea,
};

extern const uint8_t sTestCert_ICA01_PublicKey_Len = sizeof(sTestCert_ICA01_PublicKey);

extern const uint8_t sTestCert_ICA01_PrivateKey[] = {
    0x11, 0x84, 0x3b, 0xdc, 0xf0, 0xad, 0x20, 0x6d, 0xb1, 0x02, 0x51, 0xa5, 0x4d, 0xac, 0x58, 0x1d,
    0x75, 0xf9, 0x92, 0xfc, 0xb5, 0x22, 0x75, 0x2a, 0x21, 0x6c, 0xd7, 0x9c, 0x71, 0x75, 0x46, 0xa9,
};

extern const uint8_t sTestCert_ICA01_PrivateKey_Len = sizeof(sTestCert_ICA01_PrivateKey);

extern const uint8_t sTestCert_ICA01_SubjectKeyId[] = {
    0x53, 0x52, 0xD7, 0x05, 0x9E, 0x9C, 0x15, 0xA5, 0x08, 0x90, 0x68, 0x62, 0x86, 0x48, 0x01, 0xA2, 0x9F, 0x1F, 0x41, 0xD3,
};

extern const uint8_t sTestCert_ICA01_SubjectKeyId_Len = sizeof(sTestCert_ICA01_SubjectKeyId);

/**************  Test ICA02 Certificate  **************
Certificate:
    Data:
        Version: 3 (0x2)
        Serial Number: 911518014129873355 (0xca65ccdee94a1cb)
        Signature Algorithm: ecdsa-with-SHA256
        Issuer: 1.3.6.1.4.1.37244.1.4 = CACACACA00000002, 1.3.6.1.4.1.37244.1.5 = FAB000000000001D
        Validity
            Not Before: Oct 15 14:23:43 2020 GMT
            Not After : Oct 15 14:23:42 2040 GMT
        Subject: 1.3.6.1.4.1.37244.1.3 = CACACACA00000004, 1.3.6.1.4.1.37244.1.5 = FAB000000000001D
        Subject Public Key Info:
            Public Key Algorithm: id-ecPublicKey
                Public-Key: (256 bit)
                pub:
                    04:fc:fe:1a:0f:49:7d:f8:c7:fa:de:82:42:ee:b4:
                    09:e4:48:50:ee:52:bc:e0:2b:33:1e:ab:3e:af:90:
                    0c:42:04:d9:ea:a3:17:38:e6:de:94:83:45:28:de:
                    9c:35:3f:5e:5b:11:fb:92:dd:db:64:74:da:f6:0e:
                    1f:fe:21:f4:d3
                ASN1 OID: prime256v1
                NIST CURVE: P-256
        X509v3 extensions:
            X509v3 Basic Constraints: critical
                CA:TRUE
            X509v3 Key Usage: critical
                Certificate Sign, CRL Sign
            X509v3 Subject Key Identifier:
                CF:42:BC:F8:DF:48:09:D9:26:6F:23:15:5A:16:B0:7F:04:BB:3D:84
            X509v3 Authority Key Identifier:
                keyid:B2:1B:EA:40:AB:F2:AB:A9:56:F9:82:E1:DA:D2:B6:06:92:06:90:E0

    Signature Algorithm: ecdsa-with-SHA256
         30:45:02:21:00:ca:49:9e:8e:2c:5d:01:12:44:a9:2e:7e:17:
         d4:b0:52:6a:83:85:5c:8f:15:4f:f0:f1:c1:94:72:e1:f1:65:
         26:02:20:33:87:03:f4:41:10:1e:09:c8:9b:a9:b0:f6:3f:74:
         a2:6e:26:2e:b6:2b:0f:39:5a:c2:03:11:be:d0:9e:e5:e6

-----BEGIN CERTIFICATE-----
MIIB4TCCAYegAwIBAgIIDKZcze6UocswCgYIKoZIzj0EAwIwRDEgMB4GCisGAQQB
gqJ8AQQMEENBQ0FDQUNBMDAwMDAwMDIxIDAeBgorBgEEAYKifAEFDBBGQUIwMDAw
MDAwMDAwMDFEMB4XDTIwMTAxNTE0MjM0M1oXDTQwMTAxNTE0MjM0MlowRDEgMB4G
CisGAQQBgqJ8AQMMEENBQ0FDQUNBMDAwMDAwMDQxIDAeBgorBgEEAYKifAEFDBBG
QUIwMDAwMDAwMDAwMDFEMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE/P4aD0l9
+Mf63oJC7rQJ5EhQ7lK84CszHqs+r5AMQgTZ6qMXOObelINFKN6cNT9eWxH7kt3b
ZHTa9g4f/iH006NjMGEwDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAQYw
HQYDVR0OBBYEFM9CvPjfSAnZJm8jFVoWsH8Euz2EMB8GA1UdIwQYMBaAFLIb6kCr
8qupVvmC4drStgaSBpDgMAoGCCqGSM49BAMCA0gAMEUCIQDKSZ6OLF0BEkSpLn4X
1LBSaoOFXI8VT/DxwZRy4fFlJgIgM4cD9EEQHgnIm6mw9j90om4mLrYrDzlawgMR
vtCe5eY=
-----END CERTIFICATE-----

-----BEGIN EC PRIVATE KEY-----
MHcCAQEEICqDNVdDrwSjhcgPl3Le0DADVJYdhNw7MMKO5PvBdWf6oAoGCCqGSM49
AwEHoUQDQgAE/P4aD0l9+Mf63oJC7rQJ5EhQ7lK84CszHqs+r5AMQgTZ6qMXOObe
lINFKN6cNT9eWxH7kt3bZHTa9g4f/iH00w==
-----END EC PRIVATE KEY-----
*/

extern const uint8_t sTestCert_ICA02_Chip[] = {
    0x15, 0x30, 0x01, 0x08, 0x0c, 0xa6, 0x5c, 0xcd, 0xee, 0x94, 0xa1, 0xcb, 0x24, 0x02, 0x01, 0x37, 0x03, 0x27, 0x14, 0x02, 0x00,
    0x00, 0x00, 0xca, 0xca, 0xca, 0xca, 0x27, 0x15, 0x1d, 0x00, 0x00, 0x00, 0x00, 0x00, 0xb0, 0xfa, 0x18, 0x26, 0x04, 0xef, 0x17,
    0x1b, 0x27, 0x26, 0x05, 0x6e, 0xb5, 0xb9, 0x4c, 0x37, 0x06, 0x27, 0x13, 0x04, 0x00, 0x00, 0x00, 0xca, 0xca, 0xca, 0xca, 0x27,
    0x15, 0x1d, 0x00, 0x00, 0x00, 0x00, 0x00, 0xb0, 0xfa, 0x18, 0x24, 0x07, 0x01, 0x24, 0x08, 0x01, 0x30, 0x09, 0x41, 0x04, 0xfc,
    0xfe, 0x1a, 0x0f, 0x49, 0x7d, 0xf8, 0xc7, 0xfa, 0xde, 0x82, 0x42, 0xee, 0xb4, 0x09, 0xe4, 0x48, 0x50, 0xee, 0x52, 0xbc, 0xe0,
    0x2b, 0x33, 0x1e, 0xab, 0x3e, 0xaf, 0x90, 0x0c, 0x42, 0x04, 0xd9, 0xea, 0xa3, 0x17, 0x38, 0xe6, 0xde, 0x94, 0x83, 0x45, 0x28,
    0xde, 0x9c, 0x35, 0x3f, 0x5e, 0x5b, 0x11, 0xfb, 0x92, 0xdd, 0xdb, 0x64, 0x74, 0xda, 0xf6, 0x0e, 0x1f, 0xfe, 0x21, 0xf4, 0xd3,
    0x37, 0x0a, 0x35, 0x01, 0x29, 0x01, 0x18, 0x24, 0x02, 0x60, 0x30, 0x04, 0x14, 0xcf, 0x42, 0xbc, 0xf8, 0xdf, 0x48, 0x09, 0xd9,
    0x26, 0x6f, 0x23, 0x15, 0x5a, 0x16, 0xb0, 0x7f, 0x04, 0xbb, 0x3d, 0x84, 0x30, 0x05, 0x14, 0xb2, 0x1b, 0xea, 0x40, 0xab, 0xf2,
    0xab, 0xa9, 0x56, 0xf9, 0x82, 0xe1, 0xda, 0xd2, 0xb6, 0x06, 0x92, 0x06, 0x90, 0xe0, 0x18, 0x30, 0x0b, 0x40, 0xca, 0x49, 0x9e,
    0x8e, 0x2c, 0x5d, 0x01, 0x12, 0x44, 0xa9, 0x2e, 0x7e, 0x17, 0xd4, 0xb0, 0x52, 0x6a, 0x83, 0x85, 0x5c, 0x8f, 0x15, 0x4f, 0xf0,
    0xf1, 0xc1, 0x94, 0x72, 0xe1, 0xf1, 0x65, 0x26, 0x33, 0x87, 0x03, 0xf4, 0x41, 0x10, 0x1e, 0x09, 0xc8, 0x9b, 0xa9, 0xb0, 0xf6,
    0x3f, 0x74, 0xa2, 0x6e, 0x26, 0x2e, 0xb6, 0x2b, 0x0f, 0x39, 0x5a, 0xc2, 0x03, 0x11, 0xbe, 0xd0, 0x9e, 0xe5, 0xe6, 0x18,
};

extern const uint32_t sTestCert_ICA02_Chip_Len = sizeof(sTestCert_ICA02_Chip);

extern const uint8_t sTestCert_ICA02_DER[] = {
    0x30, 0x82, 0x01, 0xe1, 0x30, 0x82, 0x01, 0x87, 0xa0, 0x03, 0x02, 0x01, 0x02, 0x02, 0x08, 0x0c, 0xa6, 0x5c, 0xcd, 0xee, 0x94,
    0xa1, 0xcb, 0x30, 0x0a, 0x06, 0x08, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x04, 0x03, 0x02, 0x30, 0x44, 0x31, 0x20, 0x30, 0x1e, 0x06,
    0x0a, 0x2b, 0x06, 0x01, 0x04, 0x01, 0x82, 0xa2, 0x7c, 0x01, 0x04, 0x0c, 0x10, 0x43, 0x41, 0x43, 0x41, 0x43, 0x41, 0x43, 0x41,
    0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x31, 0x20, 0x30, 0x1e, 0x06, 0x0a, 0x2b, 0x06, 0x01, 0x04, 0x01, 0x82, 0xa2,
    0x7c, 0x01, 0x05, 0x0c, 0x10, 0x46, 0x41, 0x42, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x44,
    0x30, 0x1e, 0x17, 0x0d, 0x32, 0x30, 0x31, 0x30, 0x31, 0x35, 0x31, 0x34, 0x32, 0x33, 0x34, 0x33, 0x5a, 0x17, 0x0d, 0x34, 0x30,
    0x31, 0x30, 0x31, 0x35, 0x31, 0x34, 0x32, 0x33, 0x34, 0x32, 0x5a, 0x30, 0x44, 0x31, 0x20, 0x30, 0x1e, 0x06, 0x0a, 0x2b, 0x06,
    0x01, 0x04, 0x01, 0x82, 0xa2, 0x7c, 0x01, 0x03, 0x0c, 0x10, 0x43, 0x41, 0x43, 0x41, 0x43, 0x41, 0x43, 0x41, 0x30, 0x30, 0x30,
    0x30, 0x30, 0x30, 0x30, 0x34, 0x31, 0x20, 0x30, 0x1e, 0x06, 0x0a, 0x2b, 0x06, 0x01, 0x04, 0x01, 0x82, 0xa2, 0x7c, 0x01, 0x05,
    0x0c, 0x10, 0x46, 0x41, 0x42, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x44, 0x30, 0x59, 0x30,
    0x13, 0x06, 0x07, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x02, 0x01, 0x06, 0x08, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x03, 0x01, 0x07, 0x03,
    0x42, 0x00, 0x04, 0xfc, 0xfe, 0x1a, 0x0f, 0x49, 0x7d, 0xf8, 0xc7, 0xfa, 0xde, 0x82, 0x42, 0xee, 0xb4, 0x09, 0xe4, 0x48, 0x50,
    0xee, 0x52, 0xbc, 0xe0, 0x2b, 0x33, 0x1e, 0xab, 0x3e, 0xaf, 0x90, 0x0c, 0x42, 0x04, 0xd9, 0xea, 0xa3, 0x17, 0x38, 0xe6, 0xde,
    0x94, 0x83, 0x45, 0x28, 0xde, 0x9c, 0x35, 0x3f, 0x5e, 0x5b, 0x11, 0xfb, 0x92, 0xdd, 0xdb, 0x64, 0x74, 0xda, 0xf6, 0x0e, 0x1f,
    0xfe, 0x21, 0xf4, 0xd3, 0xa3, 0x63, 0x30, 0x61, 0x30, 0x0f, 0x06, 0x03, 0x55, 0x1d, 0x13, 0x01, 0x01, 0xff, 0x04, 0x05, 0x30,
    0x03, 0x01, 0x01, 0xff, 0x30, 0x0e, 0x06, 0x03, 0x55, 0x1d, 0x0f, 0x01, 0x01, 0xff, 0x04, 0x04, 0x03, 0x02, 0x01, 0x06, 0x30,
    0x1d, 0x06, 0x03, 0x55, 0x1d, 0x0e, 0x04, 0x16, 0x04, 0x14, 0xcf, 0x42, 0xbc, 0xf8, 0xdf, 0x48, 0x09, 0xd9, 0x26, 0x6f, 0x23,
    0x15, 0x5a, 0x16, 0xb0, 0x7f, 0x04, 0xbb, 0x3d, 0x84, 0x30, 0x1f, 0x06, 0x03, 0x55, 0x1d, 0x23, 0x04, 0x18, 0x30, 0x16, 0x80,
    0x14, 0xb2, 0x1b, 0xea, 0x40, 0xab, 0xf2, 0xab, 0xa9, 0x56, 0xf9, 0x82, 0xe1, 0xda, 0xd2, 0xb6, 0x06, 0x92, 0x06, 0x90, 0xe0,
    0x30, 0x0a, 0x06, 0x08, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x04, 0x03, 0x02, 0x03, 0x48, 0x00, 0x30, 0x45, 0x02, 0x21, 0x00, 0xca,
    0x49, 0x9e, 0x8e, 0x2c, 0x5d, 0x01, 0x12, 0x44, 0xa9, 0x2e, 0x7e, 0x17, 0xd4, 0xb0, 0x52, 0x6a, 0x83, 0x85, 0x5c, 0x8f, 0x15,
    0x4f, 0xf0, 0xf1, 0xc1, 0x94, 0x72, 0xe1, 0xf1, 0x65, 0x26, 0x02, 0x20, 0x33, 0x87, 0x03, 0xf4, 0x41, 0x10, 0x1e, 0x09, 0xc8,
    0x9b, 0xa9, 0xb0, 0xf6, 0x3f, 0x74, 0xa2, 0x6e, 0x26, 0x2e, 0xb6, 0x2b, 0x0f, 0x39, 0x5a, 0xc2, 0x03, 0x11, 0xbe, 0xd0, 0x9e,
    0xe5, 0xe6,
};

extern const uint32_t sTestCert_ICA02_DER_Len = sizeof(sTestCert_ICA02_DER);

extern const uint8_t sTestCert_ICA02_PublicKey[] = {
    0x04, 0xfc, 0xfe, 0x1a, 0x0f, 0x49, 0x7d, 0xf8, 0xc7, 0xfa, 0xde, 0x82, 0x42, 0xee, 0xb4, 0x09, 0xe4,
    0x48, 0x50, 0xee, 0x52, 0xbc, 0xe0, 0x2b, 0x33, 0x1e, 0xab, 0x3e, 0xaf, 0x90, 0x0c, 0x42, 0x04, 0xd9,
    0xea, 0xa3, 0x17, 0x38, 0xe6, 0xde, 0x94, 0x83, 0x45, 0x28, 0xde, 0x9c, 0x35, 0x3f, 0x5e, 0x5b, 0x11,
    0xfb, 0x92, 0xdd, 0xdb, 0x64, 0x74, 0xda, 0xf6, 0x0e, 0x1f, 0xfe, 0x21, 0xf4, 0xd3,
};

extern const uint8_t sTestCert_ICA02_PublicKey_Len = sizeof(sTestCert_ICA02_PublicKey);

extern const uint8_t sTestCert_ICA02_PrivateKey[] = {
    0x2a, 0x83, 0x35, 0x57, 0x43, 0xaf, 0x04, 0xa3, 0x85, 0xc8, 0x0f, 0x97, 0x72, 0xde, 0xd0, 0x30,
    0x03, 0x54, 0x96, 0x1d, 0x84, 0xdc, 0x3b, 0x30, 0xc2, 0x8e, 0xe4, 0xfb, 0xc1, 0x75, 0x67, 0xfa,
};

extern const uint8_t sTestCert_ICA02_PrivateKey_Len = sizeof(sTestCert_ICA02_PrivateKey);

extern const uint8_t sTestCert_ICA02_SubjectKeyId[] = {
    0xCF, 0x42, 0xBC, 0xF8, 0xDF, 0x48, 0x09, 0xD9, 0x26, 0x6F, 0x23, 0x15, 0x5A, 0x16, 0xB0, 0x7F, 0x04, 0xBB, 0x3D, 0x84,
};

extern const uint8_t sTestCert_ICA02_SubjectKeyId_Len = sizeof(sTestCert_ICA02_SubjectKeyId);

/**************  Test ICA01_1 Certificate  **************
Certificate:
    Data:
        Version: 3 (0x2)
        Serial Number: 4944100787284197233 (0x449cf97897cdbf71)
        Signature Algorithm: ecdsa-with-SHA256
        Issuer: 1.3.6.1.4.1.37244.1.4 = CACACACA00000001
        Validity
            Not Before: Oct 15 14:23:43 2020 GMT
            Not After : Oct 15 14:23:42 2040 GMT
        Subject: 1.3.6.1.4.1.37244.1.3 = CACACACA00000005
        Subject Public Key Info:
            Public Key Algorithm: id-ecPublicKey
                Public-Key: (256 bit)
                pub:
                    04:9b:54:14:20:29:26:1b:a1:22:95:62:72:4c:66:
                    7f:6a:0b:82:5c:fc:80:18:d9:50:24:13:71:82:4d:
                    73:52:59:51:88:2a:12:d4:48:d5:ef:28:1c:cc:73:
                    90:e3:bc:c6:41:b3:db:27:2a:37:4a:d0:22:ec:c3:
                    4e:3d:2c:8d:7a
                ASN1 OID: prime256v1
                NIST CURVE: P-256
        X509v3 extensions:
            X509v3 Basic Constraints: critical
                CA:TRUE
            X509v3 Key Usage: critical
                Certificate Sign, CRL Sign
            X509v3 Subject Key Identifier:
                93:88:3C:64:9F:C1:7E:C1:2A:6A:1D:77:CF:B9:97:2A:55:9C:1A:D8
            X509v3 Authority Key Identifier:
                keyid:13:AF:81:AB:37:37:4B:2E:D2:A9:64:9B:12:B7:A3:A4:28:7E:15:1D

    Signature Algorithm: ecdsa-with-SHA256
         30:46:02:21:00:f7:81:3c:ac:a8:23:82:ec:45:45:1e:ed:2e:
         16:2d:40:99:f9:d6:bf:43:a6:7a:0e:6d:a2:a0:a3:e3:c8:b5:
         50:02:21:00:bc:8a:e4:d3:cc:1c:d0:4f:f7:56:ed:d9:fe:b3:
         aa:89:6f:3d:db:d7:1a:e0:54:12:aa:06:61:af:42:7e:cb:57

-----BEGIN CERTIFICATE-----
MIIBnjCCAUOgAwIBAgIIRJz5eJfNv3EwCgYIKoZIzj0EAwIwIjEgMB4GCisGAQQB
gqJ8AQQMEENBQ0FDQUNBMDAwMDAwMDEwHhcNMjAxMDE1MTQyMzQzWhcNNDAxMDE1
MTQyMzQyWjAiMSAwHgYKKwYBBAGConwBAwwQQ0FDQUNBQ0EwMDAwMDAwNTBZMBMG
ByqGSM49AgEGCCqGSM49AwEHA0IABJtUFCApJhuhIpVickxmf2oLglz8gBjZUCQT
cYJNc1JZUYgqEtRI1e8oHMxzkOO8xkGz2ycqN0rQIuzDTj0sjXqjYzBhMA8GA1Ud
EwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgEGMB0GA1UdDgQWBBSTiDxkn8F+wSpq
HXfPuZcqVZwa2DAfBgNVHSMEGDAWgBQTr4GrNzdLLtKpZJsSt6OkKH4VHTAKBggq
hkjOPQQDAgNJADBGAiEA94E8rKgjguxFRR7tLhYtQJn51r9DpnoObaKgo+PItVAC
IQC8iuTTzBzQT/dW7dn+s6qJbz3b1xrgVBKqBmGvQn7LVw==
-----END CERTIFICATE-----

-----BEGIN EC PRIVATE KEY-----
MHcCAQEEIH3ikExGQpvTymBLFf/9K8D4fLAj/EvRLZMPSw218YFXoAoGCCqGSM49
AwEHoUQDQgAEm1QUICkmG6EilWJyTGZ/aguCXPyAGNlQJBNxgk1zUllRiCoS1EjV
7ygczHOQ47zGQbPbJyo3StAi7MNOPSyNeg==
-----END EC PRIVATE KEY-----
*/

extern const uint8_t sTestCert_ICA01_1_Chip[] = {
    0x15, 0x30, 0x01, 0x08, 0x44, 0x9c, 0xf9, 0x78, 0x97, 0xcd, 0xbf, 0x71, 0x24, 0x02, 0x01, 0x37, 0x03, 0x27, 0x14, 0x01, 0x00,
    0x00, 0x00, 0xca, 0xca, 0xca, 0xca, 0x18, 0x26, 0x04, 0xef, 0x17, 0x1b, 0x27, 0x26, 0x05, 0x6e, 0xb5, 0xb9, 0x4c, 0x37, 0x06,
    0x27, 0x13, 0x05, 0x00, 0x00, 0x00, 0xca, 0xca, 0xca, 0xca, 0x18, 0x24, 0x07, 0x01, 0x24, 0x08, 0x01, 0x30, 0x09, 0x41, 0x04,
    0x9b, 0x54, 0x14, 0x20, 0x29, 0x26, 0x1b, 0xa1, 0x22, 0x95, 0x62, 0x72, 0x4c, 0x66, 0x7f, 0x6a, 0x0b, 0x82, 0x5c, 0xfc, 0x80,
    0x18, 0xd9, 0x50, 0x24, 0x13, 0x71, 0x82, 0x4d, 0x73, 0x52, 0x59, 0x51, 0x88, 0x2a, 0x12, 0xd4, 0x48, 0xd5, 0xef, 0x28, 0x1c,
    0xcc, 0x73, 0x90, 0xe3, 0xbc, 0xc6, 0x41, 0xb3, 0xdb, 0x27, 0x2a, 0x37, 0x4a, 0xd0, 0x22, 0xec, 0xc3, 0x4e, 0x3d, 0x2c, 0x8d,
    0x7a, 0x37, 0x0a, 0x35, 0x01, 0x29, 0x01, 0x18, 0x24, 0x02, 0x60, 0x30, 0x04, 0x14, 0x93, 0x88, 0x3c, 0x64, 0x9f, 0xc1, 0x7e,
    0xc1, 0x2a, 0x6a, 0x1d, 0x77, 0xcf, 0xb9, 0x97, 0x2a, 0x55, 0x9c, 0x1a, 0xd8, 0x30, 0x05, 0x14, 0x13, 0xaf, 0x81, 0xab, 0x37,
    0x37, 0x4b, 0x2e, 0xd2, 0xa9, 0x64, 0x9b, 0x12, 0xb7, 0xa3, 0xa4, 0x28, 0x7e, 0x15, 0x1d, 0x18, 0x30, 0x0b, 0x40, 0xf7, 0x81,
    0x3c, 0xac, 0xa8, 0x23, 0x82, 0xec, 0x45, 0x45, 0x1e, 0xed, 0x2e, 0x16, 0x2d, 0x40, 0x99, 0xf9, 0xd6, 0xbf, 0x43, 0xa6, 0x7a,
    0x0e, 0x6d, 0xa2, 0xa0, 0xa3, 0xe3, 0xc8, 0xb5, 0x50, 0xbc, 0x8a, 0xe4, 0xd3, 0xcc, 0x1c, 0xd0, 0x4f, 0xf7, 0x56, 0xed, 0xd9,
    0xfe, 0xb3, 0xaa, 0x89, 0x6f, 0x3d, 0xdb, 0xd7, 0x1a, 0xe0, 0x54, 0x12, 0xaa, 0x06, 0x61, 0xaf, 0x42, 0x7e, 0xcb, 0x57, 0x18,
};

extern const uint32_t sTestCert_ICA01_1_Chip_Len = sizeof(sTestCert_ICA01_1_Chip);

extern const uint8_t sTestCert_ICA01_1_DER[] = {
    0x30, 0x82, 0x01, 0x9e, 0x30, 0x82, 0x01, 0x43, 0xa0, 0x03, 0x02, 0x01, 0x02, 0x02, 0x08, 0x44, 0x9c, 0xf9, 0x78, 0x97, 0xcd,
    0xbf, 0x71, 0x30, 0x0a, 0x06, 0x08, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x04, 0x03, 0x02, 0x30, 0x22, 0x31, 0x20, 0x30, 0x1e, 0x06,
    0x0a, 0x2b, 0x06, 0x01, 0x04, 0x01, 0x82, 0xa2, 0x7c, 0x01, 0x04, 0x0c, 0x10, 0x43, 0x41, 0x43, 0x41, 0x43, 0x41, 0x43, 0x41,
    0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x1e, 0x17, 0x0d, 0x32, 0x30, 0x31, 0x30, 0x31, 0x35, 0x31, 0x34, 0x32,
    0x33, 0x34, 0x33, 0x5a, 0x17, 0x0d, 0x34, 0x30, 0x31, 0x30, 0x31, 0x35, 0x31, 0x34, 0x32, 0x33, 0x34, 0x32, 0x5a, 0x30, 0x22,
    0x31, 0x20, 0x30, 0x1e, 0x06, 0x0a, 0x2b, 0x06, 0x01, 0x04, 0x01, 0x82, 0xa2, 0x7c, 0x01, 0x03, 0x0c, 0x10, 0x43, 0x41, 0x43,
    0x41, 0x43, 0x41, 0x43, 0x41, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x59, 0x30, 0x13, 0x06, 0x07, 0x2a, 0x86,
    0x48, 0xce, 0x3d, 0x02, 0x01, 0x06, 0x08, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x03, 0x01, 0x07, 0x03, 0x42, 0x00, 0x04, 0x9b, 0x54,
    0x14, 0x20, 0x29, 0x26, 0x1b, 0xa1, 0x22, 0x95, 0x62, 0x72, 0x4c, 0x66, 0x7f, 0x6a, 0x0b, 0x82, 0x5c, 0xfc, 0x80, 0x18, 0xd9,
    0x50, 0x24, 0x13, 0x71, 0x82, 0x4d, 0x73, 0x52, 0x59, 0x51, 0x88, 0x2a, 0x12, 0xd4, 0x48, 0xd5, 0xef, 0x28, 0x1c, 0xcc, 0x73,
    0x90, 0xe3, 0xbc, 0xc6, 0x41, 0xb3, 0xdb, 0x27, 0x2a, 0x37, 0x4a, 0xd0, 0x22, 0xec, 0xc3, 0x4e, 0x3d, 0x2c, 0x8d, 0x7a, 0xa3,
    0x63, 0x30, 0x61, 0x30, 0x0f, 0x06, 0x03, 0x55, 0x1d, 0x13, 0x01, 0x01, 0xff, 0x04, 0x05, 0x30, 0x03, 0x01, 0x01, 0xff, 0x30,
    0x0e, 0x06, 0x03, 0x55, 0x1d, 0x0f, 0x01, 0x01, 0xff, 0x04, 0x04, 0x03, 0x02, 0x01, 0x06, 0x30, 0x1d, 0x06, 0x03, 0x55, 0x1d,
    0x0e, 0x04, 0x16, 0x04, 0x14, 0x93, 0x88, 0x3c, 0x64, 0x9f, 0xc1, 0x7e, 0xc1, 0x2a, 0x6a, 0x1d, 0x77, 0xcf, 0xb9, 0x97, 0x2a,
    0x55, 0x9c, 0x1a, 0xd8, 0x30, 0x1f, 0x06, 0x03, 0x55, 0x1d, 0x23, 0x04, 0x18, 0x30, 0x16, 0x80, 0x14, 0x13, 0xaf, 0x81, 0xab,
    0x37, 0x37, 0x4b, 0x2e, 0xd2, 0xa9, 0x64, 0x9b, 0x12, 0xb7, 0xa3, 0xa4, 0x28, 0x7e, 0x15, 0x1d, 0x30, 0x0a, 0x06, 0x08, 0x2a,
    0x86, 0x48, 0xce, 0x3d, 0x04, 0x03, 0x02, 0x03, 0x49, 0x00, 0x30, 0x46, 0x02, 0x21, 0x00, 0xf7, 0x81, 0x3c, 0xac, 0xa8, 0x23,
    0x82, 0xec, 0x45, 0x45, 0x1e, 0xed, 0x2e, 0x16, 0x2d, 0x40, 0x99, 0xf9, 0xd6, 0xbf, 0x43, 0xa6, 0x7a, 0x0e, 0x6d, 0xa2, 0xa0,
    0xa3, 0xe3, 0xc8, 0xb5, 0x50, 0x02, 0x21, 0x00, 0xbc, 0x8a, 0xe4, 0xd3, 0xcc, 0x1c, 0xd0, 0x4f, 0xf7, 0x56, 0xed, 0xd9, 0xfe,
    0xb3, 0xaa, 0x89, 0x6f, 0x3d, 0xdb, 0xd7, 0x1a, 0xe0, 0x54, 0x12, 0xaa, 0x06, 0x61, 0xaf, 0x42, 0x7e, 0xcb, 0x57,
};

extern const uint32_t sTestCert_ICA01_1_DER_Len = sizeof(sTestCert_ICA01_1_DER);

extern const uint8_t sTestCert_ICA01_1_PublicKey[] = {
    0x04, 0x9b, 0x54, 0x14, 0x20, 0x29, 0x26, 0x1b, 0xa1, 0x22, 0x95, 0x62, 0x72, 0x4c, 0x66, 0x7f, 0x6a,
    0x0b, 0x82, 0x5c, 0xfc, 0x80, 0x18, 0xd9, 0x50, 0x24, 0x13, 0x71, 0x82, 0x4d, 0x73, 0x52, 0x59, 0x51,
    0x88, 0x2a, 0x12, 0xd4, 0x48, 0xd5, 0xef, 0x28, 0x1c, 0xcc, 0x73, 0x90, 0xe3, 0xbc, 0xc6, 0x41, 0xb3,
    0xdb, 0x27, 0x2a, 0x37, 0x4a, 0xd0, 0x22, 0xec, 0xc3, 0x4e, 0x3d, 0x2c, 0x8d, 0x7a,
};

extern const uint8_t sTestCert_ICA01_1_PublicKey_Len = sizeof(sTestCert_ICA01_1_PublicKey);

extern const uint8_t sTestCert_ICA01_1_PrivateKey[] = {
    0x7d, 0xe2, 0x90, 0x4c, 0x46, 0x42, 0x9b, 0xd3, 0xca, 0x60, 0x4b, 0x15, 0xff, 0xfd, 0x2b, 0xc0,
    0xf8, 0x7c, 0xb0, 0x23, 0xfc, 0x4b, 0xd1, 0x2d, 0x93, 0x0f, 0x4b, 0x0d, 0xb5, 0xf1, 0x81, 0x57,
};

extern const uint8_t sTestCert_ICA01_1_PrivateKey_Len = sizeof(sTestCert_ICA01_1_PrivateKey);

extern const uint8_t sTestCert_ICA01_1_SubjectKeyId[] = {
    0x93, 0x88, 0x3C, 0x64, 0x9F, 0xC1, 0x7E, 0xC1, 0x2A, 0x6A, 0x1D, 0x77, 0xCF, 0xB9, 0x97, 0x2A, 0x55, 0x9C, 0x1A, 0xD8,
};

extern const uint8_t sTestCert_ICA01_1_SubjectKeyId_Len = sizeof(sTestCert_ICA01_1_SubjectKeyId);

/**************  Test FWSign01 Certificate  **************
Certificate:
    Data:
        Version: 3 (0x2)
        Serial Number: 7114055507392117267 (0x62ba33cac684ba13)
        Signature Algorithm: ecdsa-with-SHA256
        Issuer: 1.3.6.1.4.1.37244.1.3 = CACACACA00000005
        Validity
            Not Before: Oct 15 14:23:43 2020 GMT
            Not After : Oct 15 14:23:42 2040 GMT
        Subject: 1.3.6.1.4.1.37244.1.2 = FFFFFFFF00000001, CN = FW SIGN CERT 01
        Subject Public Key Info:
            Public Key Algorithm: id-ecPublicKey
                Public-Key: (256 bit)
                pub:
                    04:e1:81:d9:cf:f5:16:d6:e0:f6:e1:70:3c:40:4a:
                    ef:fe:96:09:64:87:9e:c8:4f:25:39:92:ce:db:2a:
                    e6:44:a8:63:05:31:6f:69:e2:c6:56:bd:cc:9b:10:
                    29:68:3f:0b:af:97:28:2e:1c:ee:89:3b:cc:f3:56:
                    fb:86:e6:e3:64
                ASN1 OID: prime256v1
                NIST CURVE: P-256
        X509v3 extensions:
            X509v3 Basic Constraints: critical
                CA:FALSE
            X509v3 Key Usage: critical
                Digital Signature
            X509v3 Extended Key Usage: critical
                Code Signing
            X509v3 Subject Key Identifier:
                91:5B:BB:66:70:1F:63:1B:86:5D:40:51:A4:E0:0E:CD:7C:06:B0:0C
            X509v3 Authority Key Identifier:
                keyid:93:88:3C:64:9F:C1:7E:C1:2A:6A:1D:77:CF:B9:97:2A:55:9C:1A:D8

    Signature Algorithm: ecdsa-with-SHA256
         30:44:02:20:28:1b:51:a9:11:5c:11:ce:ff:f2:e9:d7:58:d9:
         16:92:db:c3:1d:14:89:4c:a1:35:67:fe:30:75:c4:44:71:e9:
         02:20:5c:d3:9b:f9:5d:21:46:c0:99:5e:b0:e0:5c:14:a1:3c:
         69:5f:1d:f2:0f:2c:7a:7d:48:58:c5:f4:c7:1d:68:95

-----BEGIN CERTIFICATE-----
MIIByzCCAXKgAwIBAgIIYrozysaEuhMwCgYIKoZIzj0EAwIwIjEgMB4GCisGAQQB
gqJ8AQMMEENBQ0FDQUNBMDAwMDAwMDUwHhcNMjAxMDE1MTQyMzQzWhcNNDAxMDE1
MTQyMzQyWjA8MSAwHgYKKwYBBAGConwBAgwQRkZGRkZGRkYwMDAwMDAwMTEYMBYG
A1UEAwwPRlcgU0lHTiBDRVJUIDAxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE
4YHZz/UW1uD24XA8QErv/pYJZIeeyE8lOZLO2yrmRKhjBTFvaeLGVr3MmxApaD8L
r5coLhzuiTvM81b7hubjZKN4MHYwDAYDVR0TAQH/BAIwADAOBgNVHQ8BAf8EBAMC
B4AwFgYDVR0lAQH/BAwwCgYIKwYBBQUHAwMwHQYDVR0OBBYEFJFbu2ZwH2Mbhl1A
UaTgDs18BrAMMB8GA1UdIwQYMBaAFJOIPGSfwX7BKmodd8+5lypVnBrYMAoGCCqG
SM49BAMCA0cAMEQCICgbUakRXBHO//Lp11jZFpLbwx0UiUyhNWf+MHXERHHpAiBc
05v5XSFGwJlesOBcFKE8aV8d8g8sen1IWMX0xx1olQ==
-----END CERTIFICATE-----

-----BEGIN EC PRIVATE KEY-----
MHcCAQEEII8chAINodENL5Z6hVn4oIsm+luGPuyHxc4v3h4kdjjyoAoGCCqGSM49
AwEHoUQDQgAE4YHZz/UW1uD24XA8QErv/pYJZIeeyE8lOZLO2yrmRKhjBTFvaeLG
Vr3MmxApaD8Lr5coLhzuiTvM81b7hubjZA==
-----END EC PRIVATE KEY-----
*/

extern const uint8_t sTestCert_FWSign01_Chip[] = {
    0x15, 0x30, 0x01, 0x08, 0x62, 0xba, 0x33, 0xca, 0xc6, 0x84, 0xba, 0x13, 0x24, 0x02, 0x01, 0x37, 0x03, 0x27, 0x13, 0x05,
    0x00, 0x00, 0x00, 0xca, 0xca, 0xca, 0xca, 0x18, 0x26, 0x04, 0xef, 0x17, 0x1b, 0x27, 0x26, 0x05, 0x6e, 0xb5, 0xb9, 0x4c,
    0x37, 0x06, 0x27, 0x12, 0x01, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x2c, 0x01, 0x0f, 0x46, 0x57, 0x20, 0x53, 0x49,
    0x47, 0x4e, 0x20, 0x43, 0x45, 0x52, 0x54, 0x20, 0x30, 0x31, 0x18, 0x24, 0x07, 0x01, 0x24, 0x08, 0x01, 0x30, 0x09, 0x41,
    0x04, 0xe1, 0x81, 0xd9, 0xcf, 0xf5, 0x16, 0xd6, 0xe0, 0xf6, 0xe1, 0x70, 0x3c, 0x40, 0x4a, 0xef, 0xfe, 0x96, 0x09, 0x64,
    0x87, 0x9e, 0xc8, 0x4f, 0x25, 0x39, 0x92, 0xce, 0xdb, 0x2a, 0xe6, 0x44, 0xa8, 0x63, 0x05, 0x31, 0x6f, 0x69, 0xe2, 0xc6,
    0x56, 0xbd, 0xcc, 0x9b, 0x10, 0x29, 0x68, 0x3f, 0x0b, 0xaf, 0x97, 0x28, 0x2e, 0x1c, 0xee, 0x89, 0x3b, 0xcc, 0xf3, 0x56,
    0xfb, 0x86, 0xe6, 0xe3, 0x64, 0x37, 0x0a, 0x35, 0x01, 0x28, 0x01, 0x18, 0x24, 0x02, 0x01, 0x36, 0x03, 0x04, 0x03, 0x18,
    0x30, 0x04, 0x14, 0x91, 0x5b, 0xbb, 0x66, 0x70, 0x1f, 0x63, 0x1b, 0x86, 0x5d, 0x40, 0x51, 0xa4, 0xe0, 0x0e, 0xcd, 0x7c,
    0x06, 0xb0, 0x0c, 0x30, 0x05, 0x14, 0x93, 0x88, 0x3c, 0x64, 0x9f, 0xc1, 0x7e, 0xc1, 0x2a, 0x6a, 0x1d, 0x77, 0xcf, 0xb9,
    0x97, 0x2a, 0x55, 0x9c, 0x1a, 0xd8, 0x18, 0x30, 0x0b, 0x40, 0x28, 0x1b, 0x51, 0xa9, 0x11, 0x5c, 0x11, 0xce, 0xff, 0xf2,
    0xe9, 0xd7, 0x58, 0xd9, 0x16, 0x92, 0xdb, 0xc3, 0x1d, 0x14, 0x89, 0x4c, 0xa1, 0x35, 0x67, 0xfe, 0x30, 0x75, 0xc4, 0x44,
    0x71, 0xe9, 0x5c, 0xd3, 0x9b, 0xf9, 0x5d, 0x21, 0x46, 0xc0, 0x99, 0x5e, 0xb0, 0xe0, 0x5c, 0x14, 0xa1, 0x3c, 0x69, 0x5f,
    0x1d, 0xf2, 0x0f, 0x2c, 0x7a, 0x7d, 0x48, 0x58, 0xc5, 0xf4, 0xc7, 0x1d, 0x68, 0x95, 0x18,
};

extern const uint32_t sTestCert_FWSign01_Chip_Len = sizeof(sTestCert_FWSign01_Chip);

extern const uint8_t sTestCert_FWSign01_DER[] = {
    0x30, 0x82, 0x01, 0xcb, 0x30, 0x82, 0x01, 0x72, 0xa0, 0x03, 0x02, 0x01, 0x02, 0x02, 0x08, 0x62, 0xba, 0x33, 0xca, 0xc6, 0x84,
    0xba, 0x13, 0x30, 0x0a, 0x06, 0x08, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x04, 0x03, 0x02, 0x30, 0x22, 0x31, 0x20, 0x30, 0x1e, 0x06,
    0x0a, 0x2b, 0x06, 0x01, 0x04, 0x01, 0x82, 0xa2, 0x7c, 0x01, 0x03, 0x0c, 0x10, 0x43, 0x41, 0x43, 0x41, 0x43, 0x41, 0x43, 0x41,
    0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x1e, 0x17, 0x0d, 0x32, 0x30, 0x31, 0x30, 0x31, 0x35, 0x31, 0x34, 0x32,
    0x33, 0x34, 0x33, 0x5a, 0x17, 0x0d, 0x34, 0x30, 0x31, 0x30, 0x31, 0x35, 0x31, 0x34, 0x32, 0x33, 0x34, 0x32, 0x5a, 0x30, 0x3c,
    0x31, 0x20, 0x30, 0x1e, 0x06, 0x0a, 0x2b, 0x06, 0x01, 0x04, 0x01, 0x82, 0xa2, 0x7c, 0x01, 0x02, 0x0c, 0x10, 0x46, 0x46, 0x46,
    0x46, 0x46, 0x46, 0x46, 0x46, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x18, 0x30, 0x16, 0x06, 0x03, 0x55, 0x04,
    0x03, 0x0c, 0x0f, 0x46, 0x57, 0x20, 0x53, 0x49, 0x47, 0x4e, 0x20, 0x43, 0x45, 0x52, 0x54, 0x20, 0x30, 0x31, 0x30, 0x59, 0x30,
    0x13, 0x06, 0x07, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x02, 0x01, 0x06, 0x08, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x03, 0x01, 0x07, 0x03,
    0x42, 0x00, 0x04, 0xe1, 0x81, 0xd9, 0xcf, 0xf5, 0x16, 0xd6, 0xe0, 0xf6, 0xe1, 0x70, 0x3c, 0x40, 0x4a, 0xef, 0xfe, 0x96, 0x09,
    0x64, 0x87, 0x9e, 0xc8, 0x4f, 0x25, 0x39, 0x92, 0xce, 0xdb, 0x2a, 0xe6, 0x44, 0xa8, 0x63, 0x05, 0x31, 0x6f, 0x69, 0xe2, 0xc6,
    0x56, 0xbd, 0xcc, 0x9b, 0x10, 0x29, 0x68, 0x3f, 0x0b, 0xaf, 0x97, 0x28, 0x2e, 0x1c, 0xee, 0x89, 0x3b, 0xcc, 0xf3, 0x56, 0xfb,
    0x86, 0xe6, 0xe3, 0x64, 0xa3, 0x78, 0x30, 0x76, 0x30, 0x0c, 0x06, 0x03, 0x55, 0x1d, 0x13, 0x01, 0x01, 0xff, 0x04, 0x02, 0x30,
    0x00, 0x30, 0x0e, 0x06, 0x03, 0x55, 0x1d, 0x0f, 0x01, 0x01, 0xff, 0x04, 0x04, 0x03, 0x02, 0x07, 0x80, 0x30, 0x16, 0x06, 0x03,
    0x55, 0x1d, 0x25, 0x01, 0x01, 0xff, 0x04, 0x0c, 0x30, 0x0a, 0x06, 0x08, 0x2b, 0x06, 0x01, 0x05, 0x05, 0x07, 0x03, 0x03, 0x30,
    0x1d, 0x06, 0x03, 0x55, 0x1d, 0x0e, 0x04, 0x16, 0x04, 0x14, 0x91, 0x5b, 0xbb, 0x66, 0x70, 0x1f, 0x63, 0x1b, 0x86, 0x5d, 0x40,
    0x51, 0xa4, 0xe0, 0x0e, 0xcd, 0x7c, 0x06, 0xb0, 0x0c, 0x30, 0x1f, 0x06, 0x03, 0x55, 0x1d, 0x23, 0x04, 0x18, 0x30, 0x16, 0x80,
    0x14, 0x93, 0x88, 0x3c, 0x64, 0x9f, 0xc1, 0x7e, 0xc1, 0x2a, 0x6a, 0x1d, 0x77, 0xcf, 0xb9, 0x97, 0x2a, 0x55, 0x9c, 0x1a, 0xd8,
    0x30, 0x0a, 0x06, 0x08, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x04, 0x03, 0x02, 0x03, 0x47, 0x00, 0x30, 0x44, 0x02, 0x20, 0x28, 0x1b,
    0x51, 0xa9, 0x11, 0x5c, 0x11, 0xce, 0xff, 0xf2, 0xe9, 0xd7, 0x58, 0xd9, 0x16, 0x92, 0xdb, 0xc3, 0x1d, 0x14, 0x89, 0x4c, 0xa1,
    0x35, 0x67, 0xfe, 0x30, 0x75, 0xc4, 0x44, 0x71, 0xe9, 0x02, 0x20, 0x5c, 0xd3, 0x9b, 0xf9, 0x5d, 0x21, 0x46, 0xc0, 0x99, 0x5e,
    0xb0, 0xe0, 0x5c, 0x14, 0xa1, 0x3c, 0x69, 0x5f, 0x1d, 0xf2, 0x0f, 0x2c, 0x7a, 0x7d, 0x48, 0x58, 0xc5, 0xf4, 0xc7, 0x1d, 0x68,
    0x95,
};

extern const uint32_t sTestCert_FWSign01_DER_Len = sizeof(sTestCert_FWSign01_DER);

extern const uint8_t sTestCert_FWSign01_PublicKey[] = {
    0x04, 0xe1, 0x81, 0xd9, 0xcf, 0xf5, 0x16, 0xd6, 0xe0, 0xf6, 0xe1, 0x70, 0x3c, 0x40, 0x4a, 0xef, 0xfe,
    0x96, 0x09, 0x64, 0x87, 0x9e, 0xc8, 0x4f, 0x25, 0x39, 0x92, 0xce, 0xdb, 0x2a, 0xe6, 0x44, 0xa8, 0x63,
    0x05, 0x31, 0x6f, 0x69, 0xe2, 0xc6, 0x56, 0xbd, 0xcc, 0x9b, 0x10, 0x29, 0x68, 0x3f, 0x0b, 0xaf, 0x97,
    0x28, 0x2e, 0x1c, 0xee, 0x89, 0x3b, 0xcc, 0xf3, 0x56, 0xfb, 0x86, 0xe6, 0xe3, 0x64,
};

extern const uint8_t sTestCert_FWSign01_PublicKey_Len = sizeof(sTestCert_FWSign01_PublicKey);

extern const uint8_t sTestCert_FWSign01_PrivateKey[] = {
    0x8f, 0x1c, 0x84, 0x02, 0x0d, 0xa1, 0xd1, 0x0d, 0x2f, 0x96, 0x7a, 0x85, 0x59, 0xf8, 0xa0, 0x8b,
    0x26, 0xfa, 0x5b, 0x86, 0x3e, 0xec, 0x87, 0xc5, 0xce, 0x2f, 0xde, 0x1e, 0x24, 0x76, 0x38, 0xf2,
};

extern const uint8_t sTestCert_FWSign01_PrivateKey_Len = sizeof(sTestCert_FWSign01_PrivateKey);

extern const uint8_t sTestCert_FWSign01_SubjectKeyId[] = {
    0x91, 0x5B, 0xBB, 0x66, 0x70, 0x1F, 0x63, 0x1B, 0x86, 0x5D, 0x40, 0x51, 0xA4, 0xE0, 0x0E, 0xCD, 0x7C, 0x06, 0xB0, 0x0C,
};

extern const uint8_t sTestCert_FWSign01_SubjectKeyId_Len = sizeof(sTestCert_FWSign01_SubjectKeyId);

/**************  Test Node01_01 Certificate  **************
Certificate:
    Data:
        Version: 3 (0x2)
        Serial Number: 4538782998777667962 (0x3efcff1702b9a17a)
        Signature Algorithm: ecdsa-with-SHA256
        Issuer: 1.3.6.1.4.1.37244.1.3 = CACACACA00000003
        Validity
            Not Before: Oct 15 14:23:43 2020 GMT
            Not After : Oct 15 14:23:42 2040 GMT
        Subject: 1.3.6.1.4.1.37244.1.1 = DEDEDEDE00010001, 1.3.6.1.4.1.37244.1.5 = FAB000000000001D
        Subject Public Key Info:
            Public Key Algorithm: id-ecPublicKey
                Public-Key: (256 bit)
                pub:
                    04:9a:2a:21:6f:b3:9d:d6:b6:fa:21:1b:83:5c:89:
                    e3:e6:af:b6:6c:14:f7:58:31:95:4f:9f:f4:f7:a3:
                    f0:11:2c:8a:0d:8e:af:29:c6:53:29:4d:48:ee:e0:
                    70:8a:03:2c:ca:39:39:3c:3a:7b:46:f1:81:ae:a0:
                    78:fe:ad:83:83
                ASN1 OID: prime256v1
                NIST CURVE: P-256
        X509v3 extensions:
            X509v3 Basic Constraints: critical
                CA:FALSE
            X509v3 Key Usage: critical
                Digital Signature
            X509v3 Extended Key Usage: critical
                TLS Web Client Authentication, TLS Web Server Authentication
            X509v3 Subject Key Identifier:
                9F:55:A2:6B:7E:43:03:E6:08:83:E9:13:BF:94:F4:FB:5E:2A:61:61
            X509v3 Authority Key Identifier:
                keyid:53:52:D7:05:9E:9C:15:A5:08:90:68:62:86:48:01:A2:9F:1F:41:D3

    Signature Algorithm: ecdsa-with-SHA256
         30:45:02:20:79:55:c2:02:63:0b:4b:a4:d5:91:25:26:32:2f:
         df:28:f8:9e:df:e5:af:9c:0e:57:2b:d8:a1:4a:aa:bb:4d:12:
         02:21:00:b8:3c:a1:7c:7b:05:fb:16:4b:77:d7:9c:52:96:13:
         31:6b:cf:d1:78:95:e4:b2:a4:f2:40:4b:98:17:32:71:59

-----BEGIN CERTIFICATE-----
MIIB4DCCAYagAwIBAgIIPvz/FwK5oXowCgYIKoZIzj0EAwIwIjEgMB4GCisGAQQB
gqJ8AQMMEENBQ0FDQUNBMDAwMDAwMDMwHhcNMjAxMDE1MTQyMzQzWhcNNDAxMDE1
MTQyMzQyWjBEMSAwHgYKKwYBBAGConwBAQwQREVERURFREUwMDAxMDAwMTEgMB4G
CisGAQQBgqJ8AQUMEEZBQjAwMDAwMDAwMDAwMUQwWTATBgcqhkjOPQIBBggqhkjO
PQMBBwNCAASaKiFvs53WtvohG4NciePmr7ZsFPdYMZVPn/T3o/ARLIoNjq8pxlMp
TUju4HCKAyzKOTk8OntG8YGuoHj+rYODo4GDMIGAMAwGA1UdEwEB/wQCMAAwDgYD
VR0PAQH/BAQDAgeAMCAGA1UdJQEB/wQWMBQGCCsGAQUFBwMCBggrBgEFBQcDATAd
BgNVHQ4EFgQUn1Wia35DA+YIg+kTv5T0+14qYWEwHwYDVR0jBBgwFoAUU1LXBZ6c
FaUIkGhihkgBop8fQdMwCgYIKoZIzj0EAwIDSAAwRQIgeVXCAmMLS6TVkSUmMi/f
KPie3+WvnA5XK9ihSqq7TRICIQC4PKF8ewX7Fkt315xSlhMxa8/ReJXksqTyQEuY
FzJxWQ==
-----END CERTIFICATE-----

-----BEGIN EC PRIVATE KEY-----
MHcCAQEEIKVls/ooqO1qdPtvD/ik00DZ4a6Y8h36HwpZpOoCGhYnoAoGCCqGSM49
AwEHoUQDQgAEmiohb7Od1rb6IRuDXInj5q+2bBT3WDGVT5/096PwESyKDY6vKcZT
KU1I7uBwigMsyjk5PDp7RvGBrqB4/q2Dgw==
-----END EC PRIVATE KEY-----
*/

extern const uint8_t sTestCert_Node01_01_Chip[] = {
    0x15, 0x30, 0x01, 0x08, 0x3e, 0xfc, 0xff, 0x17, 0x02, 0xb9, 0xa1, 0x7a, 0x24, 0x02, 0x01, 0x37, 0x03, 0x27, 0x13, 0x03, 0x00,
    0x00, 0x00, 0xca, 0xca, 0xca, 0xca, 0x18, 0x26, 0x04, 0xef, 0x17, 0x1b, 0x27, 0x26, 0x05, 0x6e, 0xb5, 0xb9, 0x4c, 0x37, 0x06,
    0x27, 0x11, 0x01, 0x00, 0x01, 0x00, 0xde, 0xde, 0xde, 0xde, 0x27, 0x15, 0x1d, 0x00, 0x00, 0x00, 0x00, 0x00, 0xb0, 0xfa, 0x18,
    0x24, 0x07, 0x01, 0x24, 0x08, 0x01, 0x30, 0x09, 0x41, 0x04, 0x9a, 0x2a, 0x21, 0x6f, 0xb3, 0x9d, 0xd6, 0xb6, 0xfa, 0x21, 0x1b,
    0x83, 0x5c, 0x89, 0xe3, 0xe6, 0xaf, 0xb6, 0x6c, 0x14, 0xf7, 0x58, 0x31, 0x95, 0x4f, 0x9f, 0xf4, 0xf7, 0xa3, 0xf0, 0x11, 0x2c,
    0x8a, 0x0d, 0x8e, 0xaf, 0x29, 0xc6, 0x53, 0x29, 0x4d, 0x48, 0xee, 0xe0, 0x70, 0x8a, 0x03, 0x2c, 0xca, 0x39, 0x39, 0x3c, 0x3a,
    0x7b, 0x46, 0xf1, 0x81, 0xae, 0xa0, 0x78, 0xfe, 0xad, 0x83, 0x83, 0x37, 0x0a, 0x35, 0x01, 0x28, 0x01, 0x18, 0x24, 0x02, 0x01,
    0x36, 0x03, 0x04, 0x02, 0x04, 0x01, 0x18, 0x30, 0x04, 0x14, 0x9f, 0x55, 0xa2, 0x6b, 0x7e, 0x43, 0x03, 0xe6, 0x08, 0x83, 0xe9,
    0x13, 0xbf, 0x94, 0xf4, 0xfb, 0x5e, 0x2a, 0x61, 0x61, 0x30, 0x05, 0x14, 0x53, 0x52, 0xd7, 0x05, 0x9e, 0x9c, 0x15, 0xa5, 0x08,
    0x90, 0x68, 0x62, 0x86, 0x48, 0x01, 0xa2, 0x9f, 0x1f, 0x41, 0xd3, 0x18, 0x30, 0x0b, 0x40, 0x79, 0x55, 0xc2, 0x02, 0x63, 0x0b,
    0x4b, 0xa4, 0xd5, 0x91, 0x25, 0x26, 0x32, 0x2f, 0xdf, 0x28, 0xf8, 0x9e, 0xdf, 0xe5, 0xaf, 0x9c, 0x0e, 0x57, 0x2b, 0xd8, 0xa1,
    0x4a, 0xaa, 0xbb, 0x4d, 0x12, 0xb8, 0x3c, 0xa1, 0x7c, 0x7b, 0x05, 0xfb, 0x16, 0x4b, 0x77, 0xd7, 0x9c, 0x52, 0x96, 0x13, 0x31,
    0x6b, 0xcf, 0xd1, 0x78, 0x95, 0xe4, 0xb2, 0xa4, 0xf2, 0x40, 0x4b, 0x98, 0x17, 0x32, 0x71, 0x59, 0x18,
};

extern const uint32_t sTestCert_Node01_01_Chip_Len = sizeof(sTestCert_Node01_01_Chip);

extern const uint8_t sTestCert_Node01_01_DER[] = {
    0x30, 0x82, 0x01, 0xe0, 0x30, 0x82, 0x01, 0x86, 0xa0, 0x03, 0x02, 0x01, 0x02, 0x02, 0x08, 0x3e, 0xfc, 0xff, 0x17, 0x02, 0xb9,
    0xa1, 0x7a, 0x30, 0x0a, 0x06, 0x08, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x04, 0x03, 0x02, 0x30, 0x22, 0x31, 0x20, 0x30, 0x1e, 0x06,
    0x0a, 0x2b, 0x06, 0x01, 0x04, 0x01, 0x82, 0xa2, 0x7c, 0x01, 0x03, 0x0c, 0x10, 0x43, 0x41, 0x43, 0x41, 0x43, 0x41, 0x43, 0x41,
    0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x1e, 0x17, 0x0d, 0x32, 0x30, 0x31, 0x30, 0x31, 0x35, 0x31, 0x34, 0x32,
    0x33, 0x34, 0x33, 0x5a, 0x17, 0x0d, 0x34, 0x30, 0x31, 0x30, 0x31, 0x35, 0x31, 0x34, 0x32, 0x33, 0x34, 0x32, 0x5a, 0x30, 0x44,
    0x31, 0x20, 0x30, 0x1e, 0x06, 0x0a, 0x2b, 0x06, 0x01, 0x04, 0x01, 0x82, 0xa2, 0x7c, 0x01, 0x01, 0x0c, 0x10, 0x44, 0x45, 0x44,
    0x45, 0x44, 0x45, 0x44, 0x45, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x31, 0x31, 0x20, 0x30, 0x1e, 0x06, 0x0a, 0x2b, 0x06,
    0x01, 0x04, 0x01, 0x82, 0xa2, 0x7c, 0x01, 0x05, 0x0c, 0x10, 0x46, 0x41, 0x42, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
    0x30, 0x30, 0x30, 0x31, 0x44, 0x30, 0x59, 0x30, 0x13, 0x06, 0x07, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x02, 0x01, 0x06, 0x08, 0x2a,
    0x86, 0x48, 0xce, 0x3d, 0x03, 0x01, 0x07, 0x03, 0x42, 0x00, 0x04, 0x9a, 0x2a, 0x21, 0x6f, 0xb3, 0x9d, 0xd6, 0xb6, 0xfa, 0x21,
    0x1b, 0x83, 0x5c, 0x89, 0xe3, 0xe6, 0xaf, 0xb6, 0x6c, 0x14, 0xf7, 0x58, 0x31, 0x95, 0x4f, 0x9f, 0xf4, 0xf7, 0xa3, 0xf0, 0x11,
    0x2c, 0x8a, 0x0d, 0x8e, 0xaf, 0x29, 0xc6, 0x53, 0x29, 0x4d, 0x48, 0xee, 0xe0, 0x70, 0x8a, 0x03, 0x2c, 0xca, 0x39, 0x39, 0x3c,
    0x3a, 0x7b, 0x46, 0xf1, 0x81, 0xae, 0xa0, 0x78, 0xfe, 0xad, 0x83, 0x83, 0xa3, 0x81, 0x83, 0x30, 0x81, 0x80, 0x30, 0x0c, 0x06,
    0x03, 0x55, 0x1d, 0x13, 0x01, 0x01, 0xff, 0x04, 0x02, 0x30, 0x00, 0x30, 0x0e, 0x06, 0x03, 0x55, 0x1d, 0x0f, 0x01, 0x01, 0xff,
    0x04, 0x04, 0x03, 0x02, 0x07, 0x80, 0x30, 0x20, 0x06, 0x03, 0x55, 0x1d, 0x25, 0x01, 0x01, 0xff, 0x04, 0x16, 0x30, 0x14, 0x06,
    0x08, 0x2b, 0x06, 0x01, 0x05, 0x05, 0x07, 0x03, 0x02, 0x06, 0x08, 0x2b, 0x06, 0x01, 0x05, 0x05, 0x07, 0x03, 0x01, 0x30, 0x1d,
    0x06, 0x03, 0x55, 0x1d, 0x0e, 0x04, 0x16, 0x04, 0x14, 0x9f, 0x55, 0xa2, 0x6b, 0x7e, 0x43, 0x03, 0xe6, 0x08, 0x83, 0xe9, 0x13,
    0xbf, 0x94, 0xf4, 0xfb, 0x5e, 0x2a, 0x61, 0x61, 0x30, 0x1f, 0x06, 0x03, 0x55, 0x1d, 0x23, 0x04, 0x18, 0x30, 0x16, 0x80, 0x14,
    0x53, 0x52, 0xd7, 0x05, 0x9e, 0x9c, 0x15, 0xa5, 0x08, 0x90, 0x68, 0x62, 0x86, 0x48, 0x01, 0xa2, 0x9f, 0x1f, 0x41, 0xd3, 0x30,
    0x0a, 0x06, 0x08, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x04, 0x03, 0x02, 0x03, 0x48, 0x00, 0x30, 0x45, 0x02, 0x20, 0x79, 0x55, 0xc2,
    0x02, 0x63, 0x0b, 0x4b, 0xa4, 0xd5, 0x91, 0x25, 0x26, 0x32, 0x2f, 0xdf, 0x28, 0xf8, 0x9e, 0xdf, 0xe5, 0xaf, 0x9c, 0x0e, 0x57,
    0x2b, 0xd8, 0xa1, 0x4a, 0xaa, 0xbb, 0x4d, 0x12, 0x02, 0x21, 0x00, 0xb8, 0x3c, 0xa1, 0x7c, 0x7b, 0x05, 0xfb, 0x16, 0x4b, 0x77,
    0xd7, 0x9c, 0x52, 0x96, 0x13, 0x31, 0x6b, 0xcf, 0xd1, 0x78, 0x95, 0xe4, 0xb2, 0xa4, 0xf2, 0x40, 0x4b, 0x98, 0x17, 0x32, 0x71,
    0x59,
};

extern const uint32_t sTestCert_Node01_01_DER_Len = sizeof(sTestCert_Node01_01_DER);

extern const uint8_t sTestCert_Node01_01_PublicKey[] = {
    0x04, 0x9a, 0x2a, 0x21, 0x6f, 0xb3, 0x9d, 0xd6, 0xb6, 0xfa, 0x21, 0x1b, 0x83, 0x5c, 0x89, 0xe3, 0xe6,
    0xaf, 0xb6, 0x6c, 0x14, 0xf7, 0x58, 0x31, 0x95, 0x4f, 0x9f, 0xf4, 0xf7, 0xa3, 0xf0, 0x11, 0x2c, 0x8a,
    0x0d, 0x8e, 0xaf, 0x29, 0xc6, 0x53, 0x29, 0x4d, 0x48, 0xee, 0xe0, 0x70, 0x8a, 0x03, 0x2c, 0xca, 0x39,
    0x39, 0x3c, 0x3a, 0x7b, 0x46, 0xf1, 0x81, 0xae, 0xa0, 0x78, 0xfe, 0xad, 0x83, 0x83,
};

extern const uint8_t sTestCert_Node01_01_PublicKey_Len = sizeof(sTestCert_Node01_01_PublicKey);

extern const uint8_t sTestCert_Node01_01_PrivateKey[] = {
    0xa5, 0x65, 0xb3, 0xfa, 0x28, 0xa8, 0xed, 0x6a, 0x74, 0xfb, 0x6f, 0x0f, 0xf8, 0xa4, 0xd3, 0x40,
    0xd9, 0xe1, 0xae, 0x98, 0xf2, 0x1d, 0xfa, 0x1f, 0x0a, 0x59, 0xa4, 0xea, 0x02, 0x1a, 0x16, 0x27,
};

extern const uint8_t sTestCert_Node01_01_PrivateKey_Len = sizeof(sTestCert_Node01_01_PrivateKey);

extern const uint8_t sTestCert_Node01_01_SubjectKeyId[] = {
    0x9F, 0x55, 0xA2, 0x6B, 0x7E, 0x43, 0x03, 0xE6, 0x08, 0x83, 0xE9, 0x13, 0xBF, 0x94, 0xF4, 0xFB, 0x5E, 0x2A, 0x61, 0x61,
};

extern const uint8_t sTestCert_Node01_01_SubjectKeyId_Len = sizeof(sTestCert_Node01_01_SubjectKeyId);

/**************  Test Node01_02 Certificate  **************
Certificate:
    Data:
        Version: 3 (0x2)
        Serial Number: 7164621035228478523 (0x636dd8df2b15bc3b)
        Signature Algorithm: ecdsa-with-SHA256
        Issuer: 1.3.6.1.4.1.37244.1.4 = CACACACA00000001
        Validity
            Not Before: Oct 15 14:23:43 2020 GMT
            Not After : Oct 15 14:23:42 2040 GMT
        Subject: 1.3.6.1.4.1.37244.1.1 = DEDEDEDE00010002, 1.3.6.1.4.1.37244.1.5 = FAB000000000001D
        Subject Public Key Info:
            Public Key Algorithm: id-ecPublicKey
                Public-Key: (256 bit)
                pub:
                    04:ca:44:a4:ce:f3:21:48:84:2e:4a:71:0e:c3:ee:
                    01:17:75:5d:d0:f8:8f:59:21:52:30:27:9a:97:8c:
                    d9:59:1a:3f:e0:97:69:22:ef:3f:ce:e6:8c:87:14:
                    a6:de:cc:ee:d7:cd:83:80:35:0b:a5:3f:5c:cb:f4:
                    2d:7c:6a:e8:de
                ASN1 OID: prime256v1
                NIST CURVE: P-256
        X509v3 extensions:
            X509v3 Basic Constraints: critical
                CA:FALSE
            X509v3 Key Usage: critical
                Digital Signature
            X509v3 Extended Key Usage: critical
                TLS Web Client Authentication, TLS Web Server Authentication
            X509v3 Subject Key Identifier:
                56:43:EB:BD:A3:94:98:54:CF:2B:AD:BB:E0:03:9C:1B:6D:B8:84:A7
            X509v3 Authority Key Identifier:
                keyid:13:AF:81:AB:37:37:4B:2E:D2:A9:64:9B:12:B7:A3:A4:28:7E:15:1D

    Signature Algorithm: ecdsa-with-SHA256
         30:45:02:21:00:fe:ee:e2:ff:da:c6:8f:e0:37:02:54:91:fe:
         66:80:d9:be:d4:56:de:73:a8:5e:3d:83:7b:55:59:05:08:90:
         12:02:20:77:25:f5:51:71:eb:db:6a:27:69:6a:ca:87:6a:54:
         b1:0a:20:95:e3:e7:cf:6e:cf:ee:b8:95:a6:56:1c:83:ed

-----BEGIN CERTIFICATE-----
MIIB4DCCAYagAwIBAgIIY23Y3ysVvDswCgYIKoZIzj0EAwIwIjEgMB4GCisGAQQB
gqJ8AQQMEENBQ0FDQUNBMDAwMDAwMDEwHhcNMjAxMDE1MTQyMzQzWhcNNDAxMDE1
MTQyMzQyWjBEMSAwHgYKKwYBBAGConwBAQwQREVERURFREUwMDAxMDAwMjEgMB4G
CisGAQQBgqJ8AQUMEEZBQjAwMDAwMDAwMDAwMUQwWTATBgcqhkjOPQIBBggqhkjO
PQMBBwNCAATKRKTO8yFIhC5KcQ7D7gEXdV3Q+I9ZIVIwJ5qXjNlZGj/gl2ki7z/O
5oyHFKbezO7XzYOANQulP1zL9C18aujeo4GDMIGAMAwGA1UdEwEB/wQCMAAwDgYD
VR0PAQH/BAQDAgeAMCAGA1UdJQEB/wQWMBQGCCsGAQUFBwMCBggrBgEFBQcDATAd
BgNVHQ4EFgQUVkPrvaOUmFTPK6274AOcG224hKcwHwYDVR0jBBgwFoAUE6+Bqzc3
Sy7SqWSbErejpCh+FR0wCgYIKoZIzj0EAwIDSAAwRQIhAP7u4v/axo/gNwJUkf5m
gNm+1Fbec6hePYN7VVkFCJASAiB3JfVRcevbaidpasqHalSxCiCV4+fPbs/uuJWm
VhyD7Q==
-----END CERTIFICATE-----

-----BEGIN EC PRIVATE KEY-----
MHcCAQEEIMIxNtT3b91v9x2Ao0bnjr9KpUp6f5kVY6VXo5MqS+BToAoGCCqGSM49
AwEHoUQDQgAEykSkzvMhSIQuSnEOw+4BF3Vd0PiPWSFSMCeal4zZWRo/4JdpIu8/
zuaMhxSm3szu182DgDULpT9cy/QtfGro3g==
-----END EC PRIVATE KEY-----
*/

extern const uint8_t sTestCert_Node01_02_Chip[] = {
    0x15, 0x30, 0x01, 0x08, 0x63, 0x6d, 0xd8, 0xdf, 0x2b, 0x15, 0xbc, 0x3b, 0x24, 0x02, 0x01, 0x37, 0x03, 0x27, 0x14, 0x01, 0x00,
    0x00, 0x00, 0xca, 0xca, 0xca, 0xca, 0x18, 0x26, 0x04, 0xef, 0x17, 0x1b, 0x27, 0x26, 0x05, 0x6e, 0xb5, 0xb9, 0x4c, 0x37, 0x06,
    0x27, 0x11, 0x02, 0x00, 0x01, 0x00, 0xde, 0xde, 0xde, 0xde, 0x27, 0x15, 0x1d, 0x00, 0x00, 0x00, 0x00, 0x00, 0xb0, 0xfa, 0x18,
    0x24, 0x07, 0x01, 0x24, 0x08, 0x01, 0x30, 0x09, 0x41, 0x04, 0xca, 0x44, 0xa4, 0xce, 0xf3, 0x21, 0x48, 0x84, 0x2e, 0x4a, 0x71,
    0x0e, 0xc3, 0xee, 0x01, 0x17, 0x75, 0x5d, 0xd0, 0xf8, 0x8f, 0x59, 0x21, 0x52, 0x30, 0x27, 0x9a, 0x97, 0x8c, 0xd9, 0x59, 0x1a,
    0x3f, 0xe0, 0x97, 0x69, 0x22, 0xef, 0x3f, 0xce, 0xe6, 0x8c, 0x87, 0x14, 0xa6, 0xde, 0xcc, 0xee, 0xd7, 0xcd, 0x83, 0x80, 0x35,
    0x0b, 0xa5, 0x3f, 0x5c, 0xcb, 0xf4, 0x2d, 0x7c, 0x6a, 0xe8, 0xde, 0x37, 0x0a, 0x35, 0x01, 0x28, 0x01, 0x18, 0x24, 0x02, 0x01,
    0x36, 0x03, 0x04, 0x02, 0x04, 0x01, 0x18, 0x30, 0x04, 0x14, 0x56, 0x43, 0xeb, 0xbd, 0xa3, 0x94, 0x98, 0x54, 0xcf, 0x2b, 0xad,
    0xbb, 0xe0, 0x03, 0x9c, 0x1b, 0x6d, 0xb8, 0x84, 0xa7, 0x30, 0x05, 0x14, 0x13, 0xaf, 0x81, 0xab, 0x37, 0x37, 0x4b, 0x2e, 0xd2,
    0xa9, 0x64, 0x9b, 0x12, 0xb7, 0xa3, 0xa4, 0x28, 0x7e, 0x15, 0x1d, 0x18, 0x30, 0x0b, 0x40, 0xfe, 0xee, 0xe2, 0xff, 0xda, 0xc6,
    0x8f, 0xe0, 0x37, 0x02, 0x54, 0x91, 0xfe, 0x66, 0x80, 0xd9, 0xbe, 0xd4, 0x56, 0xde, 0x73, 0xa8, 0x5e, 0x3d, 0x83, 0x7b, 0x55,
    0x59, 0x05, 0x08, 0x90, 0x12, 0x77, 0x25, 0xf5, 0x51, 0x71, 0xeb, 0xdb, 0x6a, 0x27, 0x69, 0x6a, 0xca, 0x87, 0x6a, 0x54, 0xb1,
    0x0a, 0x20, 0x95, 0xe3, 0xe7, 0xcf, 0x6e, 0xcf, 0xee, 0xb8, 0x95, 0xa6, 0x56, 0x1c, 0x83, 0xed, 0x18,
};

extern const uint32_t sTestCert_Node01_02_Chip_Len = sizeof(sTestCert_Node01_02_Chip);

extern const uint8_t sTestCert_Node01_02_DER[] = {
    0x30, 0x82, 0x01, 0xe0, 0x30, 0x82, 0x01, 0x86, 0xa0, 0x03, 0x02, 0x01, 0x02, 0x02, 0x08, 0x63, 0x6d, 0xd8, 0xdf, 0x2b, 0x15,
    0xbc, 0x3b, 0x30, 0x0a, 0x06, 0x08, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x04, 0x03, 0x02, 0x30, 0x22, 0x31, 0x20, 0x30, 0x1e, 0x06,
    0x0a, 0x2b, 0x06, 0x01, 0x04, 0x01, 0x82, 0xa2, 0x7c, 0x01, 0x04, 0x0c, 0x10, 0x43, 0x41, 0x43, 0x41, 0x43, 0x41, 0x43, 0x41,
    0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x1e, 0x17, 0x0d, 0x32, 0x30, 0x31, 0x30, 0x31, 0x35, 0x31, 0x34, 0x32,
    0x33, 0x34, 0x33, 0x5a, 0x17, 0x0d, 0x34, 0x30, 0x31, 0x30, 0x31, 0x35, 0x31, 0x34, 0x32, 0x33, 0x34, 0x32, 0x5a, 0x30, 0x44,
    0x31, 0x20, 0x30, 0x1e, 0x06, 0x0a, 0x2b, 0x06, 0x01, 0x04, 0x01, 0x82, 0xa2, 0x7c, 0x01, 0x01, 0x0c, 0x10, 0x44, 0x45, 0x44,
    0x45, 0x44, 0x45, 0x44, 0x45, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x32, 0x31, 0x20, 0x30, 0x1e, 0x06, 0x0a, 0x2b, 0x06,
    0x01, 0x04, 0x01, 0x82, 0xa2, 0x7c, 0x01, 0x05, 0x0c, 0x10, 0x46, 0x41, 0x42, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
    0x30, 0x30, 0x30, 0x31, 0x44, 0x30, 0x59, 0x30, 0x13, 0x06, 0x07, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x02, 0x01, 0x06, 0x08, 0x2a,
    0x86, 0x48, 0xce, 0x3d, 0x03, 0x01, 0x07, 0x03, 0x42, 0x00, 0x04, 0xca, 0x44, 0xa4, 0xce, 0xf3, 0x21, 0x48, 0x84, 0x2e, 0x4a,
    0x71, 0x0e, 0xc3, 0xee, 0x01, 0x17, 0x75, 0x5d, 0xd0, 0xf8, 0x8f, 0x59, 0x21, 0x52, 0x30, 0x27, 0x9a, 0x97, 0x8c, 0xd9, 0x59,
    0x1a, 0x3f, 0xe0, 0x97, 0x69, 0x22, 0xef, 0x3f, 0xce, 0xe6, 0x8c, 0x87, 0x14, 0xa6, 0xde, 0xcc, 0xee, 0xd7, 0xcd, 0x83, 0x80,
    0x35, 0x0b, 0xa5, 0x3f, 0x5c, 0xcb, 0xf4, 0x2d, 0x7c, 0x6a, 0xe8, 0xde, 0xa3, 0x81, 0x83, 0x30, 0x81, 0x80, 0x30, 0x0c, 0x06,
    0x03, 0x55, 0x1d, 0x13, 0x01, 0x01, 0xff, 0x04, 0x02, 0x30, 0x00, 0x30, 0x0e, 0x06, 0x03, 0x55, 0x1d, 0x0f, 0x01, 0x01, 0xff,
    0x04, 0x04, 0x03, 0x02, 0x07, 0x80, 0x30, 0x20, 0x06, 0x03, 0x55, 0x1d, 0x25, 0x01, 0x01, 0xff, 0x04, 0x16, 0x30, 0x14, 0x06,
    0x08, 0x2b, 0x06, 0x01, 0x05, 0x05, 0x07, 0x03, 0x02, 0x06, 0x08, 0x2b, 0x06, 0x01, 0x05, 0x05, 0x07, 0x03, 0x01, 0x30, 0x1d,
    0x06, 0x03, 0x55, 0x1d, 0x0e, 0x04, 0x16, 0x04, 0x14, 0x56, 0x43, 0xeb, 0xbd, 0xa3, 0x94, 0x98, 0x54, 0xcf, 0x2b, 0xad, 0xbb,
    0xe0, 0x03, 0x9c, 0x1b, 0x6d, 0xb8, 0x84, 0xa7, 0x30, 0x1f, 0x06, 0x03, 0x55, 0x1d, 0x23, 0x04, 0x18, 0x30, 0x16, 0x80, 0x14,
    0x13, 0xaf, 0x81, 0xab, 0x37, 0x37, 0x4b, 0x2e, 0xd2, 0xa9, 0x64, 0x9b, 0x12, 0xb7, 0xa3, 0xa4, 0x28, 0x7e, 0x15, 0x1d, 0x30,
    0x0a, 0x06, 0x08, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x04, 0x03, 0x02, 0x03, 0x48, 0x00, 0x30, 0x45, 0x02, 0x21, 0x00, 0xfe, 0xee,
    0xe2, 0xff, 0xda, 0xc6, 0x8f, 0xe0, 0x37, 0x02, 0x54, 0x91, 0xfe, 0x66, 0x80, 0xd9, 0xbe, 0xd4, 0x56, 0xde, 0x73, 0xa8, 0x5e,
    0x3d, 0x83, 0x7b, 0x55, 0x59, 0x05, 0x08, 0x90, 0x12, 0x02, 0x20, 0x77, 0x25, 0xf5, 0x51, 0x71, 0xeb, 0xdb, 0x6a, 0x27, 0x69,
    0x6a, 0xca, 0x87, 0x6a, 0x54, 0xb1, 0x0a, 0x20, 0x95, 0xe3, 0xe7, 0xcf, 0x6e, 0xcf, 0xee, 0xb8, 0x95, 0xa6, 0x56, 0x1c, 0x83,
    0xed,
};

extern const uint32_t sTestCert_Node01_02_DER_Len = sizeof(sTestCert_Node01_02_DER);

extern const uint8_t sTestCert_Node01_02_PublicKey[] = {
    0x04, 0xca, 0x44, 0xa4, 0xce, 0xf3, 0x21, 0x48, 0x84, 0x2e, 0x4a, 0x71, 0x0e, 0xc3, 0xee, 0x01, 0x17,
    0x75, 0x5d, 0xd0, 0xf8, 0x8f, 0x59, 0x21, 0x52, 0x30, 0x27, 0x9a, 0x97, 0x8c, 0xd9, 0x59, 0x1a, 0x3f,
    0xe0, 0x97, 0x69, 0x22, 0xef, 0x3f, 0xce, 0xe6, 0x8c, 0x87, 0x14, 0xa6, 0xde, 0xcc, 0xee, 0xd7, 0xcd,
    0x83, 0x80, 0x35, 0x0b, 0xa5, 0x3f, 0x5c, 0xcb, 0xf4, 0x2d, 0x7c, 0x6a, 0xe8, 0xde,
};

extern const uint8_t sTestCert_Node01_02_PublicKey_Len = sizeof(sTestCert_Node01_02_PublicKey);

extern const uint8_t sTestCert_Node01_02_PrivateKey[] = {
    0xc2, 0x31, 0x36, 0xd4, 0xf7, 0x6f, 0xdd, 0x6f, 0xf7, 0x1d, 0x80, 0xa3, 0x46, 0xe7, 0x8e, 0xbf,
    0x4a, 0xa5, 0x4a, 0x7a, 0x7f, 0x99, 0x15, 0x63, 0xa5, 0x57, 0xa3, 0x93, 0x2a, 0x4b, 0xe0, 0x53,
};

extern const uint8_t sTestCert_Node01_02_PrivateKey_Len = sizeof(sTestCert_Node01_02_PrivateKey);

extern const uint8_t sTestCert_Node01_02_SubjectKeyId[] = {
    0x56, 0x43, 0xEB, 0xBD, 0xA3, 0x94, 0x98, 0x54, 0xCF, 0x2B, 0xAD, 0xBB, 0xE0, 0x03, 0x9C, 0x1B, 0x6D, 0xB8, 0x84, 0xA7,
};

extern const uint8_t sTestCert_Node01_02_SubjectKeyId_Len = sizeof(sTestCert_Node01_02_SubjectKeyId);

/**************  Test Node02_01 Certificate  **************
Certificate:
    Data:
        Version: 3 (0x2)
        Serial Number: 2697041106332792306 (0x256dd098bf97b5f2)
        Signature Algorithm: ecdsa-with-SHA256
        Issuer: 1.3.6.1.4.1.37244.1.3 = CACACACA00000004, 1.3.6.1.4.1.37244.1.5 = FAB000000000001D
        Validity
            Not Before: Oct 15 14:23:43 2020 GMT
            Not After : Oct 15 14:23:42 2040 GMT
        Subject: 1.3.6.1.4.1.37244.1.1 = DEDEDEDE00020001, 1.3.6.1.4.1.37244.1.5 = FAB000000000001D
        Subject Public Key Info:
            Public Key Algorithm: id-ecPublicKey
                Public-Key: (256 bit)
                pub:
                    04:ba:ba:8e:3e:18:ce:fc:b6:56:8a:f6:ce:32:cc:
                    0d:df:62:5f:ed:a5:55:2a:ce:70:ed:f1:da:e9:2c:
                    a9:c0:47:de:23:e7:57:0b:25:ad:46:b8:86:fb:57:
                    f9:c2:ef:26:b5:ce:ed:f6:30:b8:f5:5a:94:5c:12:
                    51:1a:4d:9b:9a
                ASN1 OID: prime256v1
                NIST CURVE: P-256
        X509v3 extensions:
            X509v3 Basic Constraints: critical
                CA:FALSE
            X509v3 Key Usage: critical
                Digital Signature
            X509v3 Extended Key Usage: critical
                TLS Web Client Authentication, TLS Web Server Authentication
            X509v3 Subject Key Identifier:
                C2:92:42:54:44:76:84:14:9E:93:34:EF:5B:9D:A6:17:4C:33:8C:1C
            X509v3 Authority Key Identifier:
                keyid:CF:42:BC:F8:DF:48:09:D9:26:6F:23:15:5A:16:B0:7F:04:BB:3D:84

    Signature Algorithm: ecdsa-with-SHA256
         30:44:02:20:01:4c:7e:e3:ec:5f:79:18:a4:70:87:64:b5:ff:
         44:23:50:52:fc:b0:e9:4e:e8:7a:1f:68:18:f3:97:09:b1:bd:
         02:20:46:7b:f3:e6:ac:29:23:e1:81:af:75:6e:93:ca:75:95:
         a0:5c:6b:f5:09:b2:76:c0:35:a7:6a:1d:77:41:8f:00

-----BEGIN CERTIFICATE-----
MIICATCCAaigAwIBAgIIJW3QmL+XtfIwCgYIKoZIzj0EAwIwRDEgMB4GCisGAQQB
gqJ8AQMMEENBQ0FDQUNBMDAwMDAwMDQxIDAeBgorBgEEAYKifAEFDBBGQUIwMDAw
MDAwMDAwMDFEMB4XDTIwMTAxNTE0MjM0M1oXDTQwMTAxNTE0MjM0MlowRDEgMB4G
CisGAQQBgqJ8AQEMEERFREVERURFMDAwMjAwMDExIDAeBgorBgEEAYKifAEFDBBG
QUIwMDAwMDAwMDAwMDFEMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEurqOPhjO
/LZWivbOMswN32Jf7aVVKs5w7fHa6SypwEfeI+dXCyWtRriG+1f5wu8mtc7t9jC4
9VqUXBJRGk2bmqOBgzCBgDAMBgNVHRMBAf8EAjAAMA4GA1UdDwEB/wQEAwIHgDAg
BgNVHSUBAf8EFjAUBggrBgEFBQcDAgYIKwYBBQUHAwEwHQYDVR0OBBYEFMKSQlRE
doQUnpM071udphdMM4wcMB8GA1UdIwQYMBaAFM9CvPjfSAnZJm8jFVoWsH8Euz2E
MAoGCCqGSM49BAMCA0cAMEQCIAFMfuPsX3kYpHCHZLX/RCNQUvyw6U7oeh9oGPOX
CbG9AiBGe/PmrCkj4YGvdW6TynWVoFxr9QmydsA1p2odd0GPAA==
-----END CERTIFICATE-----

-----BEGIN EC PRIVATE KEY-----
MHcCAQEEIOuZ1sV6uFjXlH/QX31UCMW1x6L1r68xYJJ0IJq9IBmmoAoGCCqGSM49
AwEHoUQDQgAEurqOPhjO/LZWivbOMswN32Jf7aVVKs5w7fHa6SypwEfeI+dXCyWt
RriG+1f5wu8mtc7t9jC49VqUXBJRGk2bmg==
-----END EC PRIVATE KEY-----
*/

extern const uint8_t sTestCert_Node02_01_Chip[] = {
    0x15, 0x30, 0x01, 0x08, 0x25, 0x6d, 0xd0, 0x98, 0xbf, 0x97, 0xb5, 0xf2, 0x24, 0x02, 0x01, 0x37, 0x03, 0x27, 0x13, 0x04,
    0x00, 0x00, 0x00, 0xca, 0xca, 0xca, 0xca, 0x27, 0x15, 0x1d, 0x00, 0x00, 0x00, 0x00, 0x00, 0xb0, 0xfa, 0x18, 0x26, 0x04,
    0xef, 0x17, 0x1b, 0x27, 0x26, 0x05, 0x6e, 0xb5, 0xb9, 0x4c, 0x37, 0x06, 0x27, 0x11, 0x01, 0x00, 0x02, 0x00, 0xde, 0xde,
    0xde, 0xde, 0x27, 0x15, 0x1d, 0x00, 0x00, 0x00, 0x00, 0x00, 0xb0, 0xfa, 0x18, 0x24, 0x07, 0x01, 0x24, 0x08, 0x01, 0x30,
    0x09, 0x41, 0x04, 0xba, 0xba, 0x8e, 0x3e, 0x18, 0xce, 0xfc, 0xb6, 0x56, 0x8a, 0xf6, 0xce, 0x32, 0xcc, 0x0d, 0xdf, 0x62,
    0x5f, 0xed, 0xa5, 0x55, 0x2a, 0xce, 0x70, 0xed, 0xf1, 0xda, 0xe9, 0x2c, 0xa9, 0xc0, 0x47, 0xde, 0x23, 0xe7, 0x57, 0x0b,
    0x25, 0xad, 0x46, 0xb8, 0x86, 0xfb, 0x57, 0xf9, 0xc2, 0xef, 0x26, 0xb5, 0xce, 0xed, 0xf6, 0x30, 0xb8, 0xf5, 0x5a, 0x94,
    0x5c, 0x12, 0x51, 0x1a, 0x4d, 0x9b, 0x9a, 0x37, 0x0a, 0x35, 0x01, 0x28, 0x01, 0x18, 0x24, 0x02, 0x01, 0x36, 0x03, 0x04,
    0x02, 0x04, 0x01, 0x18, 0x30, 0x04, 0x14, 0xc2, 0x92, 0x42, 0x54, 0x44, 0x76, 0x84, 0x14, 0x9e, 0x93, 0x34, 0xef, 0x5b,
    0x9d, 0xa6, 0x17, 0x4c, 0x33, 0x8c, 0x1c, 0x30, 0x05, 0x14, 0xcf, 0x42, 0xbc, 0xf8, 0xdf, 0x48, 0x09, 0xd9, 0x26, 0x6f,
    0x23, 0x15, 0x5a, 0x16, 0xb0, 0x7f, 0x04, 0xbb, 0x3d, 0x84, 0x18, 0x30, 0x0b, 0x40, 0x01, 0x4c, 0x7e, 0xe3, 0xec, 0x5f,
    0x79, 0x18, 0xa4, 0x70, 0x87, 0x64, 0xb5, 0xff, 0x44, 0x23, 0x50, 0x52, 0xfc, 0xb0, 0xe9, 0x4e, 0xe8, 0x7a, 0x1f, 0x68,
    0x18, 0xf3, 0x97, 0x09, 0xb1, 0xbd, 0x46, 0x7b, 0xf3, 0xe6, 0xac, 0x29, 0x23, 0xe1, 0x81, 0xaf, 0x75, 0x6e, 0x93, 0xca,
    0x75, 0x95, 0xa0, 0x5c, 0x6b, 0xf5, 0x09, 0xb2, 0x76, 0xc0, 0x35, 0xa7, 0x6a, 0x1d, 0x77, 0x41, 0x8f, 0x00, 0x18,
};

extern const uint32_t sTestCert_Node02_01_Chip_Len = sizeof(sTestCert_Node02_01_Chip);

extern const uint8_t sTestCert_Node02_01_DER[] = {
    0x30, 0x82, 0x02, 0x01, 0x30, 0x82, 0x01, 0xa8, 0xa0, 0x03, 0x02, 0x01, 0x02, 0x02, 0x08, 0x25, 0x6d, 0xd0, 0x98, 0xbf, 0x97,
    0xb5, 0xf2, 0x30, 0x0a, 0x06, 0x08, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x04, 0x03, 0x02, 0x30, 0x44, 0x31, 0x20, 0x30, 0x1e, 0x06,
    0x0a, 0x2b, 0x06, 0x01, 0x04, 0x01, 0x82, 0xa2, 0x7c, 0x01, 0x03, 0x0c, 0x10, 0x43, 0x41, 0x43, 0x41, 0x43, 0x41, 0x43, 0x41,
    0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x31, 0x20, 0x30, 0x1e, 0x06, 0x0a, 0x2b, 0x06, 0x01, 0x04, 0x01, 0x82, 0xa2,
    0x7c, 0x01, 0x05, 0x0c, 0x10, 0x46, 0x41, 0x42, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x44,
    0x30, 0x1e, 0x17, 0x0d, 0x32, 0x30, 0x31, 0x30, 0x31, 0x35, 0x31, 0x34, 0x32, 0x33, 0x34, 0x33, 0x5a, 0x17, 0x0d, 0x34, 0x30,
    0x31, 0x30, 0x31, 0x35, 0x31, 0x34, 0x32, 0x33, 0x34, 0x32, 0x5a, 0x30, 0x44, 0x31, 0x20, 0x30, 0x1e, 0x06, 0x0a, 0x2b, 0x06,
    0x01, 0x04, 0x01, 0x82, 0xa2, 0x7c, 0x01, 0x01, 0x0c, 0x10, 0x44, 0x45, 0x44, 0x45, 0x44, 0x45, 0x44, 0x45, 0x30, 0x30, 0x30,
    0x32, 0x30, 0x30, 0x30, 0x31, 0x31, 0x20, 0x30, 0x1e, 0x06, 0x0a, 0x2b, 0x06, 0x01, 0x04, 0x01, 0x82, 0xa2, 0x7c, 0x01, 0x05,
    0x0c, 0x10, 0x46, 0x41, 0x42, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x44, 0x30, 0x59, 0x30,
    0x13, 0x06, 0x07, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x02, 0x01, 0x06, 0x08, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x03, 0x01, 0x07, 0x03,
    0x42, 0x00, 0x04, 0xba, 0xba, 0x8e, 0x3e, 0x18, 0xce, 0xfc, 0xb6, 0x56, 0x8a, 0xf6, 0xce, 0x32, 0xcc, 0x0d, 0xdf, 0x62, 0x5f,
    0xed, 0xa5, 0x55, 0x2a, 0xce, 0x70, 0xed, 0xf1, 0xda, 0xe9, 0x2c, 0xa9, 0xc0, 0x47, 0xde, 0x23, 0xe7, 0x57, 0x0b, 0x25, 0xad,
    0x46, 0xb8, 0x86, 0xfb, 0x57, 0xf9, 0xc2, 0xef, 0x26, 0xb5, 0xce, 0xed, 0xf6, 0x30, 0xb8, 0xf5, 0x5a, 0x94, 0x5c, 0x12, 0x51,
    0x1a, 0x4d, 0x9b, 0x9a, 0xa3, 0x81, 0x83, 0x30, 0x81, 0x80, 0x30, 0x0c, 0x06, 0x03, 0x55, 0x1d, 0x13, 0x01, 0x01, 0xff, 0x04,
    0x02, 0x30, 0x00, 0x30, 0x0e, 0x06, 0x03, 0x55, 0x1d, 0x0f, 0x01, 0x01, 0xff, 0x04, 0x04, 0x03, 0x02, 0x07, 0x80, 0x30, 0x20,
    0x06, 0x03, 0x55, 0x1d, 0x25, 0x01, 0x01, 0xff, 0x04, 0x16, 0x30, 0x14, 0x06, 0x08, 0x2b, 0x06, 0x01, 0x05, 0x05, 0x07, 0x03,
    0x02, 0x06, 0x08, 0x2b, 0x06, 0x01, 0x05, 0x05, 0x07, 0x03, 0x01, 0x30, 0x1d, 0x06, 0x03, 0x55, 0x1d, 0x0e, 0x04, 0x16, 0x04,
    0x14, 0xc2, 0x92, 0x42, 0x54, 0x44, 0x76, 0x84, 0x14, 0x9e, 0x93, 0x34, 0xef, 0x5b, 0x9d, 0xa6, 0x17, 0x4c, 0x33, 0x8c, 0x1c,
    0x30, 0x1f, 0x06, 0x03, 0x55, 0x1d, 0x23, 0x04, 0x18, 0x30, 0x16, 0x80, 0x14, 0xcf, 0x42, 0xbc, 0xf8, 0xdf, 0x48, 0x09, 0xd9,
    0x26, 0x6f, 0x23, 0x15, 0x5a, 0x16, 0xb0, 0x7f, 0x04, 0xbb, 0x3d, 0x84, 0x30, 0x0a, 0x06, 0x08, 0x2a, 0x86, 0x48, 0xce, 0x3d,
    0x04, 0x03, 0x02, 0x03, 0x47, 0x00, 0x30, 0x44, 0x02, 0x20, 0x01, 0x4c, 0x7e, 0xe3, 0xec, 0x5f, 0x79, 0x18, 0xa4, 0x70, 0x87,
    0x64, 0xb5, 0xff, 0x44, 0x23, 0x50, 0x52, 0xfc, 0xb0, 0xe9, 0x4e, 0xe8, 0x7a, 0x1f, 0x68, 0x18, 0xf3, 0x97, 0x09, 0xb1, 0xbd,
    0x02, 0x20, 0x46, 0x7b, 0xf3, 0xe6, 0xac, 0x29, 0x23, 0xe1, 0x81, 0xaf, 0x75, 0x6e, 0x93, 0xca, 0x75, 0x95, 0xa0, 0x5c, 0x6b,
    0xf5, 0x09, 0xb2, 0x76, 0xc0, 0x35, 0xa7, 0x6a, 0x1d, 0x77, 0x41, 0x8f, 0x00,
};

extern const uint32_t sTestCert_Node02_01_DER_Len = sizeof(sTestCert_Node02_01_DER);

extern const uint8_t sTestCert_Node02_01_PublicKey[] = {
    0x04, 0xba, 0xba, 0x8e, 0x3e, 0x18, 0xce, 0xfc, 0xb6, 0x56, 0x8a, 0xf6, 0xce, 0x32, 0xcc, 0x0d, 0xdf,
    0x62, 0x5f, 0xed, 0xa5, 0x55, 0x2a, 0xce, 0x70, 0xed, 0xf1, 0xda, 0xe9, 0x2c, 0xa9, 0xc0, 0x47, 0xde,
    0x23, 0xe7, 0x57, 0x0b, 0x25, 0xad, 0x46, 0xb8, 0x86, 0xfb, 0x57, 0xf9, 0xc2, 0xef, 0x26, 0xb5, 0xce,
    0xed, 0xf6, 0x30, 0xb8, 0xf5, 0x5a, 0x94, 0x5c, 0x12, 0x51, 0x1a, 0x4d, 0x9b, 0x9a,
};

extern const uint8_t sTestCert_Node02_01_PublicKey_Len = sizeof(sTestCert_Node02_01_PublicKey);

extern const uint8_t sTestCert_Node02_01_PrivateKey[] = {
    0xeb, 0x99, 0xd6, 0xc5, 0x7a, 0xb8, 0x58, 0xd7, 0x94, 0x7f, 0xd0, 0x5f, 0x7d, 0x54, 0x08, 0xc5,
    0xb5, 0xc7, 0xa2, 0xf5, 0xaf, 0xaf, 0x31, 0x60, 0x92, 0x74, 0x20, 0x9a, 0xbd, 0x20, 0x19, 0xa6,
};

extern const uint8_t sTestCert_Node02_01_PrivateKey_Len = sizeof(sTestCert_Node02_01_PrivateKey);

extern const uint8_t sTestCert_Node02_01_SubjectKeyId[] = {
    0xC2, 0x92, 0x42, 0x54, 0x44, 0x76, 0x84, 0x14, 0x9E, 0x93, 0x34, 0xEF, 0x5B, 0x9D, 0xA6, 0x17, 0x4C, 0x33, 0x8C, 0x1C,
};

extern const uint8_t sTestCert_Node02_01_SubjectKeyId_Len = sizeof(sTestCert_Node02_01_SubjectKeyId);

/**************  Test Node02_02 Certificate  **************
Certificate:
    Data:
        Version: 3 (0x2)
        Serial Number: 6640147435493508949 (0x5c268ae95ccfc755)
        Signature Algorithm: ecdsa-with-SHA256
        Issuer: 1.3.6.1.4.1.37244.1.3 = CACACACA00000004, 1.3.6.1.4.1.37244.1.5 = FAB000000000001D
        Validity
            Not Before: Oct 15 14:23:43 2020 GMT
            Not After : Oct 15 14:23:42 2040 GMT
        Subject: 1.3.6.1.4.1.37244.1.1 = DEDEDEDE00020002, 1.3.6.1.4.1.37244.1.5 = FAB000000000001D, CN = TEST CERT COMMON NAME Attr
for Node02_02 Subject Public Key Info: Public Key Algorithm: id-ecPublicKey Public-Key: (256 bit) pub:
                    04:b2:87:29:92:2c:b1:c1:eb:3a:67:c1:8a:b3:1f:
                    f3:bf:27:f8:e8:8e:1f:1d:70:98:9b:30:10:90:d0:
                    e3:62:a4:6b:47:08:11:d1:70:85:cf:69:23:85:5e:
                    7a:c7:23:61:c7:13:96:06:fc:a6:79:cf:91:65:97:
                    10:cc:e7:df:78
                ASN1 OID: prime256v1
                NIST CURVE: P-256
        X509v3 extensions:
            X509v3 Basic Constraints: critical
                CA:FALSE
            X509v3 Key Usage: critical
                Digital Signature
            X509v3 Extended Key Usage: critical
                TLS Web Client Authentication, TLS Web Server Authentication
            X509v3 Subject Key Identifier:
                40:90:A7:74:DA:49:53:CF:A8:46:66:7E:8D:7F:B7:4A:51:80:D0:EA
            X509v3 Authority Key Identifier:
                keyid:CF:42:BC:F8:DF:48:09:D9:26:6F:23:15:5A:16:B0:7F:04:BB:3D:84

    Signature Algorithm: ecdsa-with-SHA256
         30:45:02:20:46:56:be:52:4b:97:29:ff:9c:79:93:d2:86:0f:
         18:86:2d:05:93:77:10:aa:f0:50:61:3c:ab:66:57:d4:60:f1:
         02:21:00:fe:59:c2:1e:2b:2d:46:fc:b8:64:f5:f5:82:f5:45:
         f9:99:33:67:db:41:84:44:10:79:7a:60:2a:3f:15:4f:e0

-----BEGIN CERTIFICATE-----
MIICNTCCAdugAwIBAgIIXCaK6VzPx1UwCgYIKoZIzj0EAwIwRDEgMB4GCisGAQQB
gqJ8AQMMEENBQ0FDQUNBMDAwMDAwMDQxIDAeBgorBgEEAYKifAEFDBBGQUIwMDAw
MDAwMDAwMDFEMB4XDTIwMTAxNTE0MjM0M1oXDTQwMTAxNTE0MjM0MlowdzEgMB4G
CisGAQQBgqJ8AQEMEERFREVERURFMDAwMjAwMDIxIDAeBgorBgEEAYKifAEFDBBG
QUIwMDAwMDAwMDAwMDFEMTEwLwYDVQQDDChURVNUIENFUlQgQ09NTU9OIE5BTUUg
QXR0ciBmb3IgTm9kZTAyXzAyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEsocp
kiyxwes6Z8GKsx/zvyf46I4fHXCYmzAQkNDjYqRrRwgR0XCFz2kjhV56xyNhxxOW
Bvymec+RZZcQzOffeKOBgzCBgDAMBgNVHRMBAf8EAjAAMA4GA1UdDwEB/wQEAwIH
gDAgBgNVHSUBAf8EFjAUBggrBgEFBQcDAgYIKwYBBQUHAwEwHQYDVR0OBBYEFECQ
p3TaSVPPqEZmfo1/t0pRgNDqMB8GA1UdIwQYMBaAFM9CvPjfSAnZJm8jFVoWsH8E
uz2EMAoGCCqGSM49BAMCA0gAMEUCIEZWvlJLlyn/nHmT0oYPGIYtBZN3EKrwUGE8
q2ZX1GDxAiEA/lnCHistRvy4ZPX1gvVF+ZkzZ9tBhEQQeXpgKj8VT+A=
-----END CERTIFICATE-----

-----BEGIN EC PRIVATE KEY-----
MHcCAQEEII9E84s+nWG26ZmAtXeJSWFbkr6fkBuPuTWiF8YmgEk0oAoGCCqGSM49
AwEHoUQDQgAEsocpkiyxwes6Z8GKsx/zvyf46I4fHXCYmzAQkNDjYqRrRwgR0XCF
z2kjhV56xyNhxxOWBvymec+RZZcQzOffeA==
-----END EC PRIVATE KEY-----
*/

extern const uint8_t sTestCert_Node02_02_Chip[] = {
    0x15, 0x30, 0x01, 0x08, 0x5c, 0x26, 0x8a, 0xe9, 0x5c, 0xcf, 0xc7, 0x55, 0x24, 0x02, 0x01, 0x37, 0x03, 0x27, 0x13, 0x04, 0x00,
    0x00, 0x00, 0xca, 0xca, 0xca, 0xca, 0x27, 0x15, 0x1d, 0x00, 0x00, 0x00, 0x00, 0x00, 0xb0, 0xfa, 0x18, 0x26, 0x04, 0xef, 0x17,
    0x1b, 0x27, 0x26, 0x05, 0x6e, 0xb5, 0xb9, 0x4c, 0x37, 0x06, 0x27, 0x11, 0x02, 0x00, 0x02, 0x00, 0xde, 0xde, 0xde, 0xde, 0x27,
    0x15, 0x1d, 0x00, 0x00, 0x00, 0x00, 0x00, 0xb0, 0xfa, 0x2c, 0x01, 0x28, 0x54, 0x45, 0x53, 0x54, 0x20, 0x43, 0x45, 0x52, 0x54,
    0x20, 0x43, 0x4f, 0x4d, 0x4d, 0x4f, 0x4e, 0x20, 0x4e, 0x41, 0x4d, 0x45, 0x20, 0x41, 0x74, 0x74, 0x72, 0x20, 0x66, 0x6f, 0x72,
    0x20, 0x4e, 0x6f, 0x64, 0x65, 0x30, 0x32, 0x5f, 0x30, 0x32, 0x18, 0x24, 0x07, 0x01, 0x24, 0x08, 0x01, 0x30, 0x09, 0x41, 0x04,
    0xb2, 0x87, 0x29, 0x92, 0x2c, 0xb1, 0xc1, 0xeb, 0x3a, 0x67, 0xc1, 0x8a, 0xb3, 0x1f, 0xf3, 0xbf, 0x27, 0xf8, 0xe8, 0x8e, 0x1f,
    0x1d, 0x70, 0x98, 0x9b, 0x30, 0x10, 0x90, 0xd0, 0xe3, 0x62, 0xa4, 0x6b, 0x47, 0x08, 0x11, 0xd1, 0x70, 0x85, 0xcf, 0x69, 0x23,
    0x85, 0x5e, 0x7a, 0xc7, 0x23, 0x61, 0xc7, 0x13, 0x96, 0x06, 0xfc, 0xa6, 0x79, 0xcf, 0x91, 0x65, 0x97, 0x10, 0xcc, 0xe7, 0xdf,
    0x78, 0x37, 0x0a, 0x35, 0x01, 0x28, 0x01, 0x18, 0x24, 0x02, 0x01, 0x36, 0x03, 0x04, 0x02, 0x04, 0x01, 0x18, 0x30, 0x04, 0x14,
    0x40, 0x90, 0xa7, 0x74, 0xda, 0x49, 0x53, 0xcf, 0xa8, 0x46, 0x66, 0x7e, 0x8d, 0x7f, 0xb7, 0x4a, 0x51, 0x80, 0xd0, 0xea, 0x30,
    0x05, 0x14, 0xcf, 0x42, 0xbc, 0xf8, 0xdf, 0x48, 0x09, 0xd9, 0x26, 0x6f, 0x23, 0x15, 0x5a, 0x16, 0xb0, 0x7f, 0x04, 0xbb, 0x3d,
    0x84, 0x18, 0x30, 0x0b, 0x40, 0x46, 0x56, 0xbe, 0x52, 0x4b, 0x97, 0x29, 0xff, 0x9c, 0x79, 0x93, 0xd2, 0x86, 0x0f, 0x18, 0x86,
    0x2d, 0x05, 0x93, 0x77, 0x10, 0xaa, 0xf0, 0x50, 0x61, 0x3c, 0xab, 0x66, 0x57, 0xd4, 0x60, 0xf1, 0xfe, 0x59, 0xc2, 0x1e, 0x2b,
    0x2d, 0x46, 0xfc, 0xb8, 0x64, 0xf5, 0xf5, 0x82, 0xf5, 0x45, 0xf9, 0x99, 0x33, 0x67, 0xdb, 0x41, 0x84, 0x44, 0x10, 0x79, 0x7a,
    0x60, 0x2a, 0x3f, 0x15, 0x4f, 0xe0, 0x18,
};

extern const uint32_t sTestCert_Node02_02_Chip_Len = sizeof(sTestCert_Node02_02_Chip);

extern const uint8_t sTestCert_Node02_02_DER[] = {
    0x30, 0x82, 0x02, 0x35, 0x30, 0x82, 0x01, 0xdb, 0xa0, 0x03, 0x02, 0x01, 0x02, 0x02, 0x08, 0x5c, 0x26, 0x8a, 0xe9, 0x5c, 0xcf,
    0xc7, 0x55, 0x30, 0x0a, 0x06, 0x08, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x04, 0x03, 0x02, 0x30, 0x44, 0x31, 0x20, 0x30, 0x1e, 0x06,
    0x0a, 0x2b, 0x06, 0x01, 0x04, 0x01, 0x82, 0xa2, 0x7c, 0x01, 0x03, 0x0c, 0x10, 0x43, 0x41, 0x43, 0x41, 0x43, 0x41, 0x43, 0x41,
    0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x31, 0x20, 0x30, 0x1e, 0x06, 0x0a, 0x2b, 0x06, 0x01, 0x04, 0x01, 0x82, 0xa2,
    0x7c, 0x01, 0x05, 0x0c, 0x10, 0x46, 0x41, 0x42, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x44,
    0x30, 0x1e, 0x17, 0x0d, 0x32, 0x30, 0x31, 0x30, 0x31, 0x35, 0x31, 0x34, 0x32, 0x33, 0x34, 0x33, 0x5a, 0x17, 0x0d, 0x34, 0x30,
    0x31, 0x30, 0x31, 0x35, 0x31, 0x34, 0x32, 0x33, 0x34, 0x32, 0x5a, 0x30, 0x77, 0x31, 0x20, 0x30, 0x1e, 0x06, 0x0a, 0x2b, 0x06,
    0x01, 0x04, 0x01, 0x82, 0xa2, 0x7c, 0x01, 0x01, 0x0c, 0x10, 0x44, 0x45, 0x44, 0x45, 0x44, 0x45, 0x44, 0x45, 0x30, 0x30, 0x30,
    0x32, 0x30, 0x30, 0x30, 0x32, 0x31, 0x20, 0x30, 0x1e, 0x06, 0x0a, 0x2b, 0x06, 0x01, 0x04, 0x01, 0x82, 0xa2, 0x7c, 0x01, 0x05,
    0x0c, 0x10, 0x46, 0x41, 0x42, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x44, 0x31, 0x31, 0x30,
    0x2f, 0x06, 0x03, 0x55, 0x04, 0x03, 0x0c, 0x28, 0x54, 0x45, 0x53, 0x54, 0x20, 0x43, 0x45, 0x52, 0x54, 0x20, 0x43, 0x4f, 0x4d,
    0x4d, 0x4f, 0x4e, 0x20, 0x4e, 0x41, 0x4d, 0x45, 0x20, 0x41, 0x74, 0x74, 0x72, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x4e, 0x6f, 0x64,
    0x65, 0x30, 0x32, 0x5f, 0x30, 0x32, 0x30, 0x59, 0x30, 0x13, 0x06, 0x07, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x02, 0x01, 0x06, 0x08,
    0x2a, 0x86, 0x48, 0xce, 0x3d, 0x03, 0x01, 0x07, 0x03, 0x42, 0x00, 0x04, 0xb2, 0x87, 0x29, 0x92, 0x2c, 0xb1, 0xc1, 0xeb, 0x3a,
    0x67, 0xc1, 0x8a, 0xb3, 0x1f, 0xf3, 0xbf, 0x27, 0xf8, 0xe8, 0x8e, 0x1f, 0x1d, 0x70, 0x98, 0x9b, 0x30, 0x10, 0x90, 0xd0, 0xe3,
    0x62, 0xa4, 0x6b, 0x47, 0x08, 0x11, 0xd1, 0x70, 0x85, 0xcf, 0x69, 0x23, 0x85, 0x5e, 0x7a, 0xc7, 0x23, 0x61, 0xc7, 0x13, 0x96,
    0x06, 0xfc, 0xa6, 0x79, 0xcf, 0x91, 0x65, 0x97, 0x10, 0xcc, 0xe7, 0xdf, 0x78, 0xa3, 0x81, 0x83, 0x30, 0x81, 0x80, 0x30, 0x0c,
    0x06, 0x03, 0x55, 0x1d, 0x13, 0x01, 0x01, 0xff, 0x04, 0x02, 0x30, 0x00, 0x30, 0x0e, 0x06, 0x03, 0x55, 0x1d, 0x0f, 0x01, 0x01,
    0xff, 0x04, 0x04, 0x03, 0x02, 0x07, 0x80, 0x30, 0x20, 0x06, 0x03, 0x55, 0x1d, 0x25, 0x01, 0x01, 0xff, 0x04, 0x16, 0x30, 0x14,
    0x06, 0x08, 0x2b, 0x06, 0x01, 0x05, 0x05, 0x07, 0x03, 0x02, 0x06, 0x08, 0x2b, 0x06, 0x01, 0x05, 0x05, 0x07, 0x03, 0x01, 0x30,
    0x1d, 0x06, 0x03, 0x55, 0x1d, 0x0e, 0x04, 0x16, 0x04, 0x14, 0x40, 0x90, 0xa7, 0x74, 0xda, 0x49, 0x53, 0xcf, 0xa8, 0x46, 0x66,
    0x7e, 0x8d, 0x7f, 0xb7, 0x4a, 0x51, 0x80, 0xd0, 0xea, 0x30, 0x1f, 0x06, 0x03, 0x55, 0x1d, 0x23, 0x04, 0x18, 0x30, 0x16, 0x80,
    0x14, 0xcf, 0x42, 0xbc, 0xf8, 0xdf, 0x48, 0x09, 0xd9, 0x26, 0x6f, 0x23, 0x15, 0x5a, 0x16, 0xb0, 0x7f, 0x04, 0xbb, 0x3d, 0x84,
    0x30, 0x0a, 0x06, 0x08, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x04, 0x03, 0x02, 0x03, 0x48, 0x00, 0x30, 0x45, 0x02, 0x20, 0x46, 0x56,
    0xbe, 0x52, 0x4b, 0x97, 0x29, 0xff, 0x9c, 0x79, 0x93, 0xd2, 0x86, 0x0f, 0x18, 0x86, 0x2d, 0x05, 0x93, 0x77, 0x10, 0xaa, 0xf0,
    0x50, 0x61, 0x3c, 0xab, 0x66, 0x57, 0xd4, 0x60, 0xf1, 0x02, 0x21, 0x00, 0xfe, 0x59, 0xc2, 0x1e, 0x2b, 0x2d, 0x46, 0xfc, 0xb8,
    0x64, 0xf5, 0xf5, 0x82, 0xf5, 0x45, 0xf9, 0x99, 0x33, 0x67, 0xdb, 0x41, 0x84, 0x44, 0x10, 0x79, 0x7a, 0x60, 0x2a, 0x3f, 0x15,
    0x4f, 0xe0,
};

extern const uint32_t sTestCert_Node02_02_DER_Len = sizeof(sTestCert_Node02_02_DER);

extern const uint8_t sTestCert_Node02_02_PublicKey[] = {
    0x04, 0xb2, 0x87, 0x29, 0x92, 0x2c, 0xb1, 0xc1, 0xeb, 0x3a, 0x67, 0xc1, 0x8a, 0xb3, 0x1f, 0xf3, 0xbf,
    0x27, 0xf8, 0xe8, 0x8e, 0x1f, 0x1d, 0x70, 0x98, 0x9b, 0x30, 0x10, 0x90, 0xd0, 0xe3, 0x62, 0xa4, 0x6b,
    0x47, 0x08, 0x11, 0xd1, 0x70, 0x85, 0xcf, 0x69, 0x23, 0x85, 0x5e, 0x7a, 0xc7, 0x23, 0x61, 0xc7, 0x13,
    0x96, 0x06, 0xfc, 0xa6, 0x79, 0xcf, 0x91, 0x65, 0x97, 0x10, 0xcc, 0xe7, 0xdf, 0x78,
};

extern const uint8_t sTestCert_Node02_02_PublicKey_Len = sizeof(sTestCert_Node02_02_PublicKey);

extern const uint8_t sTestCert_Node02_02_PrivateKey[] = {
    0x8f, 0x44, 0xf3, 0x8b, 0x3e, 0x9d, 0x61, 0xb6, 0xe9, 0x99, 0x80, 0xb5, 0x77, 0x89, 0x49, 0x61,
    0x5b, 0x92, 0xbe, 0x9f, 0x90, 0x1b, 0x8f, 0xb9, 0x35, 0xa2, 0x17, 0xc6, 0x26, 0x80, 0x49, 0x34,
};

extern const uint8_t sTestCert_Node02_02_PrivateKey_Len = sizeof(sTestCert_Node02_02_PrivateKey);

extern const uint8_t sTestCert_Node02_02_SubjectKeyId[] = {
    0x40, 0x90, 0xA7, 0x74, 0xDA, 0x49, 0x53, 0xCF, 0xA8, 0x46, 0x66, 0x7E, 0x8D, 0x7F, 0xB7, 0x4A, 0x51, 0x80, 0xD0, 0xEA,
};

extern const uint8_t sTestCert_Node02_02_SubjectKeyId_Len = sizeof(sTestCert_Node02_02_SubjectKeyId);

/**************  Test Node02_03 Certificate  **************
Certificate:
    Data:
        Version: 3 (0x2)
        Serial Number: 7412840857549301709 (0x66dfb37c2aba67cd)
        Signature Algorithm: ecdsa-with-SHA256
        Issuer: 1.3.6.1.4.1.37244.1.3 = CACACACA00000004, 1.3.6.1.4.1.37244.1.5 = FAB000000000001D
        Validity
            Not Before: Oct 15 14:23:43 2020 GMT
            Not After : Oct 15 14:23:42 2040 GMT
        Subject: 1.3.6.1.4.1.37244.1.1 = DEDEDEDE00020003, 1.3.6.1.4.1.37244.1.5 = FAB000000000001D, CN =
TestCert02_03, 1.3.6.1.4.1.37244.1.6 = A001B001, 1.3.6.1.4.1.37244.1.7 = A001B002 Subject Public Key Info: Public Key Algorithm:
id-ecPublicKey Public-Key: (256 bit) pub: 04:43:cd:fa:bc:f2:f4:8c:10:6f:5f:d8:90:87:29:
                    ee:fd:6e:ea:92:b6:49:0e:10:53:6d:1b:0b:b0:c9:
                    7a:28:83:57:21:69:1b:2a:4e:d2:a6:52:b0:dc:19:
                    d5:2a:30:ea:2d:58:6b:b1:22:0b:69:cd:d6:eb:0a:
                    3e:e2:f2:5f:61
                ASN1 OID: prime256v1
                NIST CURVE: P-256
        X509v3 extensions:
            X509v3 Basic Constraints: critical
                CA:FALSE
            X509v3 Key Usage: critical
                Digital Signature
            X509v3 Extended Key Usage: critical
                TLS Web Client Authentication, TLS Web Server Authentication
            X509v3 Subject Key Identifier:
                31:1F:1B:10:15:5C:E5:4F:F0:C8:FC:F4:6E:F5:28:B9:B7:B0:0B:0A
            X509v3 Authority Key Identifier:
                keyid:CF:42:BC:F8:DF:48:09:D9:26:6F:23:15:5A:16:B0:7F:04:BB:3D:84

    Signature Algorithm: ecdsa-with-SHA256
         30:45:02:21:00:e1:f6:61:61:0e:c6:8a:42:e9:00:73:67:d0:
         74:f7:1a:60:80:a0:a4:4d:a6:bd:d7:d2:0f:8b:15:ec:2f:aa:
         c4:02:20:65:a5:19:47:72:e9:fd:57:66:00:3d:ce:7c:a0:c0:
         1d:66:fb:a7:2d:9b:e4:7c:ec:41:ff:29:00:3c:16:43:5d

-----BEGIN CERTIFICATE-----
MIICTzCCAfWgAwIBAgIIZt+zfCq6Z80wCgYIKoZIzj0EAwIwRDEgMB4GCisGAQQB
gqJ8AQMMEENBQ0FDQUNBMDAwMDAwMDQxIDAeBgorBgEEAYKifAEFDBBGQUIwMDAw
MDAwMDAwMDFEMB4XDTIwMTAxNTE0MjM0M1oXDTQwMTAxNTE0MjM0MlowgZAxIDAe
BgorBgEEAYKifAEBDBBERURFREVERTAwMDIwMDAzMSAwHgYKKwYBBAGConwBBQwQ
RkFCMDAwMDAwMDAwMDAxRDEWMBQGA1UEAwwNVGVzdENlcnQwMl8wMzEYMBYGCisG
AQQBgqJ8AQYMCEEwMDFCMDAxMRgwFgYKKwYBBAGConwBBwwIQTAwMUIwMDIwWTAT
BgcqhkjOPQIBBggqhkjOPQMBBwNCAARDzfq88vSMEG9f2JCHKe79buqStkkOEFNt
GwuwyXoog1chaRsqTtKmUrDcGdUqMOotWGuxIgtpzdbrCj7i8l9ho4GDMIGAMAwG
A1UdEwEB/wQCMAAwDgYDVR0PAQH/BAQDAgeAMCAGA1UdJQEB/wQWMBQGCCsGAQUF
BwMCBggrBgEFBQcDATAdBgNVHQ4EFgQUMR8bEBVc5U/wyPz0bvUoubewCwowHwYD
VR0jBBgwFoAUz0K8+N9ICdkmbyMVWhawfwS7PYQwCgYIKoZIzj0EAwIDSAAwRQIh
AOH2YWEOxopC6QBzZ9B09xpggKCkTaa919IPixXsL6rEAiBlpRlHcun9V2YAPc58
oMAdZvunLZvkfOxB/ykAPBZDXQ==
-----END CERTIFICATE-----

-----BEGIN EC PRIVATE KEY-----
MHcCAQEEIDYTSAUOkPD9dKZt+VVyWHqWM4CwpFEW8UP2RJGtRZgboAoGCCqGSM49
AwEHoUQDQgAEQ836vPL0jBBvX9iQhynu/W7qkrZJDhBTbRsLsMl6KINXIWkbKk7S
plKw3BnVKjDqLVhrsSILac3W6wo+4vJfYQ==
-----END EC PRIVATE KEY-----
*/

extern const uint8_t sTestCert_Node02_03_Chip[] = {
    0x15, 0x30, 0x01, 0x08, 0x66, 0xdf, 0xb3, 0x7c, 0x2a, 0xba, 0x67, 0xcd, 0x24, 0x02, 0x01, 0x37, 0x03, 0x27, 0x13, 0x04, 0x00,
    0x00, 0x00, 0xca, 0xca, 0xca, 0xca, 0x27, 0x15, 0x1d, 0x00, 0x00, 0x00, 0x00, 0x00, 0xb0, 0xfa, 0x18, 0x26, 0x04, 0xef, 0x17,
    0x1b, 0x27, 0x26, 0x05, 0x6e, 0xb5, 0xb9, 0x4c, 0x37, 0x06, 0x27, 0x11, 0x03, 0x00, 0x02, 0x00, 0xde, 0xde, 0xde, 0xde, 0x27,
    0x15, 0x1d, 0x00, 0x00, 0x00, 0x00, 0x00, 0xb0, 0xfa, 0x2c, 0x01, 0x0d, 0x54, 0x65, 0x73, 0x74, 0x43, 0x65, 0x72, 0x74, 0x30,
    0x32, 0x5f, 0x30, 0x33, 0x26, 0x16, 0x01, 0xb0, 0x01, 0xa0, 0x26, 0x17, 0x02, 0xb0, 0x01, 0xa0, 0x18, 0x24, 0x07, 0x01, 0x24,
    0x08, 0x01, 0x30, 0x09, 0x41, 0x04, 0x43, 0xcd, 0xfa, 0xbc, 0xf2, 0xf4, 0x8c, 0x10, 0x6f, 0x5f, 0xd8, 0x90, 0x87, 0x29, 0xee,
    0xfd, 0x6e, 0xea, 0x92, 0xb6, 0x49, 0x0e, 0x10, 0x53, 0x6d, 0x1b, 0x0b, 0xb0, 0xc9, 0x7a, 0x28, 0x83, 0x57, 0x21, 0x69, 0x1b,
    0x2a, 0x4e, 0xd2, 0xa6, 0x52, 0xb0, 0xdc, 0x19, 0xd5, 0x2a, 0x30, 0xea, 0x2d, 0x58, 0x6b, 0xb1, 0x22, 0x0b, 0x69, 0xcd, 0xd6,
    0xeb, 0x0a, 0x3e, 0xe2, 0xf2, 0x5f, 0x61, 0x37, 0x0a, 0x35, 0x01, 0x28, 0x01, 0x18, 0x24, 0x02, 0x01, 0x36, 0x03, 0x04, 0x02,
    0x04, 0x01, 0x18, 0x30, 0x04, 0x14, 0x31, 0x1f, 0x1b, 0x10, 0x15, 0x5c, 0xe5, 0x4f, 0xf0, 0xc8, 0xfc, 0xf4, 0x6e, 0xf5, 0x28,
    0xb9, 0xb7, 0xb0, 0x0b, 0x0a, 0x30, 0x05, 0x14, 0xcf, 0x42, 0xbc, 0xf8, 0xdf, 0x48, 0x09, 0xd9, 0x26, 0x6f, 0x23, 0x15, 0x5a,
    0x16, 0xb0, 0x7f, 0x04, 0xbb, 0x3d, 0x84, 0x18, 0x30, 0x0b, 0x40, 0xe1, 0xf6, 0x61, 0x61, 0x0e, 0xc6, 0x8a, 0x42, 0xe9, 0x00,
    0x73, 0x67, 0xd0, 0x74, 0xf7, 0x1a, 0x60, 0x80, 0xa0, 0xa4, 0x4d, 0xa6, 0xbd, 0xd7, 0xd2, 0x0f, 0x8b, 0x15, 0xec, 0x2f, 0xaa,
    0xc4, 0x65, 0xa5, 0x19, 0x47, 0x72, 0xe9, 0xfd, 0x57, 0x66, 0x00, 0x3d, 0xce, 0x7c, 0xa0, 0xc0, 0x1d, 0x66, 0xfb, 0xa7, 0x2d,
    0x9b, 0xe4, 0x7c, 0xec, 0x41, 0xff, 0x29, 0x00, 0x3c, 0x16, 0x43, 0x5d, 0x18,
};

extern const uint32_t sTestCert_Node02_03_Chip_Len = sizeof(sTestCert_Node02_03_Chip);

extern const uint8_t sTestCert_Node02_03_DER[] = {
    0x30, 0x82, 0x02, 0x4f, 0x30, 0x82, 0x01, 0xf5, 0xa0, 0x03, 0x02, 0x01, 0x02, 0x02, 0x08, 0x66, 0xdf, 0xb3, 0x7c, 0x2a, 0xba,
    0x67, 0xcd, 0x30, 0x0a, 0x06, 0x08, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x04, 0x03, 0x02, 0x30, 0x44, 0x31, 0x20, 0x30, 0x1e, 0x06,
    0x0a, 0x2b, 0x06, 0x01, 0x04, 0x01, 0x82, 0xa2, 0x7c, 0x01, 0x03, 0x0c, 0x10, 0x43, 0x41, 0x43, 0x41, 0x43, 0x41, 0x43, 0x41,
    0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x31, 0x20, 0x30, 0x1e, 0x06, 0x0a, 0x2b, 0x06, 0x01, 0x04, 0x01, 0x82, 0xa2,
    0x7c, 0x01, 0x05, 0x0c, 0x10, 0x46, 0x41, 0x42, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x44,
    0x30, 0x1e, 0x17, 0x0d, 0x32, 0x30, 0x31, 0x30, 0x31, 0x35, 0x31, 0x34, 0x32, 0x33, 0x34, 0x33, 0x5a, 0x17, 0x0d, 0x34, 0x30,
    0x31, 0x30, 0x31, 0x35, 0x31, 0x34, 0x32, 0x33, 0x34, 0x32, 0x5a, 0x30, 0x81, 0x90, 0x31, 0x20, 0x30, 0x1e, 0x06, 0x0a, 0x2b,
    0x06, 0x01, 0x04, 0x01, 0x82, 0xa2, 0x7c, 0x01, 0x01, 0x0c, 0x10, 0x44, 0x45, 0x44, 0x45, 0x44, 0x45, 0x44, 0x45, 0x30, 0x30,
    0x30, 0x32, 0x30, 0x30, 0x30, 0x33, 0x31, 0x20, 0x30, 0x1e, 0x06, 0x0a, 0x2b, 0x06, 0x01, 0x04, 0x01, 0x82, 0xa2, 0x7c, 0x01,
    0x05, 0x0c, 0x10, 0x46, 0x41, 0x42, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x44, 0x31, 0x16,
    0x30, 0x14, 0x06, 0x03, 0x55, 0x04, 0x03, 0x0c, 0x0d, 0x54, 0x65, 0x73, 0x74, 0x43, 0x65, 0x72, 0x74, 0x30, 0x32, 0x5f, 0x30,
    0x33, 0x31, 0x18, 0x30, 0x16, 0x06, 0x0a, 0x2b, 0x06, 0x01, 0x04, 0x01, 0x82, 0xa2, 0x7c, 0x01, 0x06, 0x0c, 0x08, 0x41, 0x30,
    0x30, 0x31, 0x42, 0x30, 0x30, 0x31, 0x31, 0x18, 0x30, 0x16, 0x06, 0x0a, 0x2b, 0x06, 0x01, 0x04, 0x01, 0x82, 0xa2, 0x7c, 0x01,
    0x07, 0x0c, 0x08, 0x41, 0x30, 0x30, 0x31, 0x42, 0x30, 0x30, 0x32, 0x30, 0x59, 0x30, 0x13, 0x06, 0x07, 0x2a, 0x86, 0x48, 0xce,
    0x3d, 0x02, 0x01, 0x06, 0x08, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x03, 0x01, 0x07, 0x03, 0x42, 0x00, 0x04, 0x43, 0xcd, 0xfa, 0xbc,
    0xf2, 0xf4, 0x8c, 0x10, 0x6f, 0x5f, 0xd8, 0x90, 0x87, 0x29, 0xee, 0xfd, 0x6e, 0xea, 0x92, 0xb6, 0x49, 0x0e, 0x10, 0x53, 0x6d,
    0x1b, 0x0b, 0xb0, 0xc9, 0x7a, 0x28, 0x83, 0x57, 0x21, 0x69, 0x1b, 0x2a, 0x4e, 0xd2, 0xa6, 0x52, 0xb0, 0xdc, 0x19, 0xd5, 0x2a,
    0x30, 0xea, 0x2d, 0x58, 0x6b, 0xb1, 0x22, 0x0b, 0x69, 0xcd, 0xd6, 0xeb, 0x0a, 0x3e, 0xe2, 0xf2, 0x5f, 0x61, 0xa3, 0x81, 0x83,
    0x30, 0x81, 0x80, 0x30, 0x0c, 0x06, 0x03, 0x55, 0x1d, 0x13, 0x01, 0x01, 0xff, 0x04, 0x02, 0x30, 0x00, 0x30, 0x0e, 0x06, 0x03,
    0x55, 0x1d, 0x0f, 0x01, 0x01, 0xff, 0x04, 0x04, 0x03, 0x02, 0x07, 0x80, 0x30, 0x20, 0x06, 0x03, 0x55, 0x1d, 0x25, 0x01, 0x01,
    0xff, 0x04, 0x16, 0x30, 0x14, 0x06, 0x08, 0x2b, 0x06, 0x01, 0x05, 0x05, 0x07, 0x03, 0x02, 0x06, 0x08, 0x2b, 0x06, 0x01, 0x05,
    0x05, 0x07, 0x03, 0x01, 0x30, 0x1d, 0x06, 0x03, 0x55, 0x1d, 0x0e, 0x04, 0x16, 0x04, 0x14, 0x31, 0x1f, 0x1b, 0x10, 0x15, 0x5c,
    0xe5, 0x4f, 0xf0, 0xc8, 0xfc, 0xf4, 0x6e, 0xf5, 0x28, 0xb9, 0xb7, 0xb0, 0x0b, 0x0a, 0x30, 0x1f, 0x06, 0x03, 0x55, 0x1d, 0x23,
    0x04, 0x18, 0x30, 0x16, 0x80, 0x14, 0xcf, 0x42, 0xbc, 0xf8, 0xdf, 0x48, 0x09, 0xd9, 0x26, 0x6f, 0x23, 0x15, 0x5a, 0x16, 0xb0,
    0x7f, 0x04, 0xbb, 0x3d, 0x84, 0x30, 0x0a, 0x06, 0x08, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x04, 0x03, 0x02, 0x03, 0x48, 0x00, 0x30,
    0x45, 0x02, 0x21, 0x00, 0xe1, 0xf6, 0x61, 0x61, 0x0e, 0xc6, 0x8a, 0x42, 0xe9, 0x00, 0x73, 0x67, 0xd0, 0x74, 0xf7, 0x1a, 0x60,
    0x80, 0xa0, 0xa4, 0x4d, 0xa6, 0xbd, 0xd7, 0xd2, 0x0f, 0x8b, 0x15, 0xec, 0x2f, 0xaa, 0xc4, 0x02, 0x20, 0x65, 0xa5, 0x19, 0x47,
    0x72, 0xe9, 0xfd, 0x57, 0x66, 0x00, 0x3d, 0xce, 0x7c, 0xa0, 0xc0, 0x1d, 0x66, 0xfb, 0xa7, 0x2d, 0x9b, 0xe4, 0x7c, 0xec, 0x41,
    0xff, 0x29, 0x00, 0x3c, 0x16, 0x43, 0x5d,
};

extern const uint32_t sTestCert_Node02_03_DER_Len = sizeof(sTestCert_Node02_03_DER);

extern const uint8_t sTestCert_Node02_03_PublicKey[] = {
    0x04, 0x43, 0xcd, 0xfa, 0xbc, 0xf2, 0xf4, 0x8c, 0x10, 0x6f, 0x5f, 0xd8, 0x90, 0x87, 0x29, 0xee, 0xfd,
    0x6e, 0xea, 0x92, 0xb6, 0x49, 0x0e, 0x10, 0x53, 0x6d, 0x1b, 0x0b, 0xb0, 0xc9, 0x7a, 0x28, 0x83, 0x57,
    0x21, 0x69, 0x1b, 0x2a, 0x4e, 0xd2, 0xa6, 0x52, 0xb0, 0xdc, 0x19, 0xd5, 0x2a, 0x30, 0xea, 0x2d, 0x58,
    0x6b, 0xb1, 0x22, 0x0b, 0x69, 0xcd, 0xd6, 0xeb, 0x0a, 0x3e, 0xe2, 0xf2, 0x5f, 0x61,
};

extern const uint8_t sTestCert_Node02_03_PublicKey_Len = sizeof(sTestCert_Node02_03_PublicKey);

extern const uint8_t sTestCert_Node02_03_PrivateKey[] = {
    0x36, 0x13, 0x48, 0x05, 0x0e, 0x90, 0xf0, 0xfd, 0x74, 0xa6, 0x6d, 0xf9, 0x55, 0x72, 0x58, 0x7a,
    0x96, 0x33, 0x80, 0xb0, 0xa4, 0x51, 0x16, 0xf1, 0x43, 0xf6, 0x44, 0x91, 0xad, 0x45, 0x98, 0x1b,
};

extern const uint8_t sTestCert_Node02_03_PrivateKey_Len = sizeof(sTestCert_Node02_03_PrivateKey);

extern const uint8_t sTestCert_Node02_03_SubjectKeyId[] = {
    0x31, 0x1F, 0x1B, 0x10, 0x15, 0x5C, 0xE5, 0x4F, 0xF0, 0xC8, 0xFC, 0xF4, 0x6E, 0xF5, 0x28, 0xB9, 0xB7, 0xB0, 0x0B, 0x0A,
};

extern const uint8_t sTestCert_Node02_03_SubjectKeyId_Len = sizeof(sTestCert_Node02_03_SubjectKeyId);

/**************  Test Node02_04 Certificate  **************
Certificate:
    Data:
        Version: 3 (0x2)
        Serial Number: 494219895904038480 (0x6dbd260784a6e50)
        Signature Algorithm: ecdsa-with-SHA256
        Issuer: 1.3.6.1.4.1.37244.1.3 = CACACACA00000004, 1.3.6.1.4.1.37244.1.5 = FAB000000000001D
        Validity
            Not Before: Oct 15 14:23:43 2020 GMT
            Not After : Oct 15 14:23:42 2040 GMT
        Subject: 1.3.6.1.4.1.37244.1.6 = A001B001, CN = TestCert02_04, 1.3.6.1.4.1.37244.1.5 =
FAB000000000001D, 1.3.6.1.4.1.37244.1.7 = A001B002, 1.3.6.1.4.1.37244.1.1 = DEDEDEDE00020004 Subject Public Key Info: Public Key
Algorithm: id-ecPublicKey Public-Key: (256 bit) pub: 04:58:eb:6f:a0:34:4a:08:45:af:cf:d6:cf:31:fe:
                    5e:92:27:4e:b6:31:ea:ad:ab:a3:4b:84:ee:8d:01:
                    6e:e2:57:d5:37:4f:be:a8:04:86:d3:d9:3f:15:1c:
                    3f:ea:24:25:a6:f4:57:b1:b7:87:79:9f:4b:a8:24:
                    01:00:99:f8:8c
                ASN1 OID: prime256v1
                NIST CURVE: P-256
        X509v3 extensions:
            X509v3 Basic Constraints: critical
                CA:FALSE
            X509v3 Key Usage: critical
                Digital Signature
            X509v3 Extended Key Usage: critical
                TLS Web Client Authentication, TLS Web Server Authentication
            X509v3 Subject Key Identifier:
                44:FA:8C:5F:32:EE:1F:FC:9D:98:1F:90:AB:2E:CC:D0:65:AC:ED:05
            X509v3 Authority Key Identifier:
                keyid:CF:42:BC:F8:DF:48:09:D9:26:6F:23:15:5A:16:B0:7F:04:BB:3D:84

    Signature Algorithm: ecdsa-with-SHA256
         30:45:02:20:58:80:e4:98:79:04:6e:c1:08:51:38:fd:42:c7:
         48:8d:fc:a1:aa:aa:81:d8:37:87:a2:ee:2a:65:d9:f2:4f:09:
         02:21:00:91:85:9a:9d:2d:08:0d:9b:0b:14:a2:28:99:f1:fb:
         c2:52:cf:52:94:a0:be:8f:3c:e5:bb:22:58:7b:9a:c2:b4

-----BEGIN CERTIFICATE-----
MIICTzCCAfWgAwIBAgIIBtvSYHhKblAwCgYIKoZIzj0EAwIwRDEgMB4GCisGAQQB
gqJ8AQMMEENBQ0FDQUNBMDAwMDAwMDQxIDAeBgorBgEEAYKifAEFDBBGQUIwMDAw
MDAwMDAwMDFEMB4XDTIwMTAxNTE0MjM0M1oXDTQwMTAxNTE0MjM0MlowgZAxGDAW
BgorBgEEAYKifAEGDAhBMDAxQjAwMTEWMBQGA1UEAwwNVGVzdENlcnQwMl8wNDEg
MB4GCisGAQQBgqJ8AQUMEEZBQjAwMDAwMDAwMDAwMUQxGDAWBgorBgEEAYKifAEH
DAhBMDAxQjAwMjEgMB4GCisGAQQBgqJ8AQEMEERFREVERURFMDAwMjAwMDQwWTAT
BgcqhkjOPQIBBggqhkjOPQMBBwNCAARY62+gNEoIRa/P1s8x/l6SJ062Meqtq6NL
hO6NAW7iV9U3T76oBIbT2T8VHD/qJCWm9Fext4d5n0uoJAEAmfiMo4GDMIGAMAwG
A1UdEwEB/wQCMAAwDgYDVR0PAQH/BAQDAgeAMCAGA1UdJQEB/wQWMBQGCCsGAQUF
BwMCBggrBgEFBQcDATAdBgNVHQ4EFgQURPqMXzLuH/ydmB+Qqy7M0GWs7QUwHwYD
VR0jBBgwFoAUz0K8+N9ICdkmbyMVWhawfwS7PYQwCgYIKoZIzj0EAwIDSAAwRQIg
WIDkmHkEbsEIUTj9QsdIjfyhqqqB2DeHou4qZdnyTwkCIQCRhZqdLQgNmwsUoiiZ
8fvCUs9SlKC+jzzluyJYe5rCtA==
-----END CERTIFICATE-----

-----BEGIN EC PRIVATE KEY-----
MHcCAQEEIEdIYYYWspTUN8CnTXQcKX+bIDQD7ns+orUuJdrxaC9woAoGCCqGSM49
AwEHoUQDQgAEWOtvoDRKCEWvz9bPMf5ekidOtjHqraujS4TujQFu4lfVN0++qASG
09k/FRw/6iQlpvRXsbeHeZ9LqCQBAJn4jA==
-----END EC PRIVATE KEY-----
*/

extern const uint8_t sTestCert_Node02_04_Chip[] = {
    0x15, 0x30, 0x01, 0x08, 0x06, 0xdb, 0xd2, 0x60, 0x78, 0x4a, 0x6e, 0x50, 0x24, 0x02, 0x01, 0x37, 0x03, 0x27, 0x13, 0x04, 0x00,
    0x00, 0x00, 0xca, 0xca, 0xca, 0xca, 0x27, 0x15, 0x1d, 0x00, 0x00, 0x00, 0x00, 0x00, 0xb0, 0xfa, 0x18, 0x26, 0x04, 0xef, 0x17,
    0x1b, 0x27, 0x26, 0x05, 0x6e, 0xb5, 0xb9, 0x4c, 0x37, 0x06, 0x26, 0x16, 0x01, 0xb0, 0x01, 0xa0, 0x2c, 0x01, 0x0d, 0x54, 0x65,
    0x73, 0x74, 0x43, 0x65, 0x72, 0x74, 0x30, 0x32, 0x5f, 0x30, 0x34, 0x27, 0x15, 0x1d, 0x00, 0x00, 0x00, 0x00, 0x00, 0xb0, 0xfa,
    0x26, 0x17, 0x02, 0xb0, 0x01, 0xa0, 0x27, 0x11, 0x04, 0x00, 0x02, 0x00, 0xde, 0xde, 0xde, 0xde, 0x18, 0x24, 0x07, 0x01, 0x24,
    0x08, 0x01, 0x30, 0x09, 0x41, 0x04, 0x58, 0xeb, 0x6f, 0xa0, 0x34, 0x4a, 0x08, 0x45, 0xaf, 0xcf, 0xd6, 0xcf, 0x31, 0xfe, 0x5e,
    0x92, 0x27, 0x4e, 0xb6, 0x31, 0xea, 0xad, 0xab, 0xa3, 0x4b, 0x84, 0xee, 0x8d, 0x01, 0x6e, 0xe2, 0x57, 0xd5, 0x37, 0x4f, 0xbe,
    0xa8, 0x04, 0x86, 0xd3, 0xd9, 0x3f, 0x15, 0x1c, 0x3f, 0xea, 0x24, 0x25, 0xa6, 0xf4, 0x57, 0xb1, 0xb7, 0x87, 0x79, 0x9f, 0x4b,
    0xa8, 0x24, 0x01, 0x00, 0x99, 0xf8, 0x8c, 0x37, 0x0a, 0x35, 0x01, 0x28, 0x01, 0x18, 0x24, 0x02, 0x01, 0x36, 0x03, 0x04, 0x02,
    0x04, 0x01, 0x18, 0x30, 0x04, 0x14, 0x44, 0xfa, 0x8c, 0x5f, 0x32, 0xee, 0x1f, 0xfc, 0x9d, 0x98, 0x1f, 0x90, 0xab, 0x2e, 0xcc,
    0xd0, 0x65, 0xac, 0xed, 0x05, 0x30, 0x05, 0x14, 0xcf, 0x42, 0xbc, 0xf8, 0xdf, 0x48, 0x09, 0xd9, 0x26, 0x6f, 0x23, 0x15, 0x5a,
    0x16, 0xb0, 0x7f, 0x04, 0xbb, 0x3d, 0x84, 0x18, 0x30, 0x0b, 0x40, 0x58, 0x80, 0xe4, 0x98, 0x79, 0x04, 0x6e, 0xc1, 0x08, 0x51,
    0x38, 0xfd, 0x42, 0xc7, 0x48, 0x8d, 0xfc, 0xa1, 0xaa, 0xaa, 0x81, 0xd8, 0x37, 0x87, 0xa2, 0xee, 0x2a, 0x65, 0xd9, 0xf2, 0x4f,
    0x09, 0x91, 0x85, 0x9a, 0x9d, 0x2d, 0x08, 0x0d, 0x9b, 0x0b, 0x14, 0xa2, 0x28, 0x99, 0xf1, 0xfb, 0xc2, 0x52, 0xcf, 0x52, 0x94,
    0xa0, 0xbe, 0x8f, 0x3c, 0xe5, 0xbb, 0x22, 0x58, 0x7b, 0x9a, 0xc2, 0xb4, 0x18,
};

extern const uint32_t sTestCert_Node02_04_Chip_Len = sizeof(sTestCert_Node02_04_Chip);

extern const uint8_t sTestCert_Node02_04_DER[] = {
    0x30, 0x82, 0x02, 0x4f, 0x30, 0x82, 0x01, 0xf5, 0xa0, 0x03, 0x02, 0x01, 0x02, 0x02, 0x08, 0x06, 0xdb, 0xd2, 0x60, 0x78, 0x4a,
    0x6e, 0x50, 0x30, 0x0a, 0x06, 0x08, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x04, 0x03, 0x02, 0x30, 0x44, 0x31, 0x20, 0x30, 0x1e, 0x06,
    0x0a, 0x2b, 0x06, 0x01, 0x04, 0x01, 0x82, 0xa2, 0x7c, 0x01, 0x03, 0x0c, 0x10, 0x43, 0x41, 0x43, 0x41, 0x43, 0x41, 0x43, 0x41,
    0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x31, 0x20, 0x30, 0x1e, 0x06, 0x0a, 0x2b, 0x06, 0x01, 0x04, 0x01, 0x82, 0xa2,
    0x7c, 0x01, 0x05, 0x0c, 0x10, 0x46, 0x41, 0x42, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x44,
    0x30, 0x1e, 0x17, 0x0d, 0x32, 0x30, 0x31, 0x30, 0x31, 0x35, 0x31, 0x34, 0x32, 0x33, 0x34, 0x33, 0x5a, 0x17, 0x0d, 0x34, 0x30,
    0x31, 0x30, 0x31, 0x35, 0x31, 0x34, 0x32, 0x33, 0x34, 0x32, 0x5a, 0x30, 0x81, 0x90, 0x31, 0x18, 0x30, 0x16, 0x06, 0x0a, 0x2b,
    0x06, 0x01, 0x04, 0x01, 0x82, 0xa2, 0x7c, 0x01, 0x06, 0x0c, 0x08, 0x41, 0x30, 0x30, 0x31, 0x42, 0x30, 0x30, 0x31, 0x31, 0x16,
    0x30, 0x14, 0x06, 0x03, 0x55, 0x04, 0x03, 0x0c, 0x0d, 0x54, 0x65, 0x73, 0x74, 0x43, 0x65, 0x72, 0x74, 0x30, 0x32, 0x5f, 0x30,
    0x34, 0x31, 0x20, 0x30, 0x1e, 0x06, 0x0a, 0x2b, 0x06, 0x01, 0x04, 0x01, 0x82, 0xa2, 0x7c, 0x01, 0x05, 0x0c, 0x10, 0x46, 0x41,
    0x42, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x44, 0x31, 0x18, 0x30, 0x16, 0x06, 0x0a, 0x2b,
    0x06, 0x01, 0x04, 0x01, 0x82, 0xa2, 0x7c, 0x01, 0x07, 0x0c, 0x08, 0x41, 0x30, 0x30, 0x31, 0x42, 0x30, 0x30, 0x32, 0x31, 0x20,
    0x30, 0x1e, 0x06, 0x0a, 0x2b, 0x06, 0x01, 0x04, 0x01, 0x82, 0xa2, 0x7c, 0x01, 0x01, 0x0c, 0x10, 0x44, 0x45, 0x44, 0x45, 0x44,
    0x45, 0x44, 0x45, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x34, 0x30, 0x59, 0x30, 0x13, 0x06, 0x07, 0x2a, 0x86, 0x48, 0xce,
    0x3d, 0x02, 0x01, 0x06, 0x08, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x03, 0x01, 0x07, 0x03, 0x42, 0x00, 0x04, 0x58, 0xeb, 0x6f, 0xa0,
    0x34, 0x4a, 0x08, 0x45, 0xaf, 0xcf, 0xd6, 0xcf, 0x31, 0xfe, 0x5e, 0x92, 0x27, 0x4e, 0xb6, 0x31, 0xea, 0xad, 0xab, 0xa3, 0x4b,
    0x84, 0xee, 0x8d, 0x01, 0x6e, 0xe2, 0x57, 0xd5, 0x37, 0x4f, 0xbe, 0xa8, 0x04, 0x86, 0xd3, 0xd9, 0x3f, 0x15, 0x1c, 0x3f, 0xea,
    0x24, 0x25, 0xa6, 0xf4, 0x57, 0xb1, 0xb7, 0x87, 0x79, 0x9f, 0x4b, 0xa8, 0x24, 0x01, 0x00, 0x99, 0xf8, 0x8c, 0xa3, 0x81, 0x83,
    0x30, 0x81, 0x80, 0x30, 0x0c, 0x06, 0x03, 0x55, 0x1d, 0x13, 0x01, 0x01, 0xff, 0x04, 0x02, 0x30, 0x00, 0x30, 0x0e, 0x06, 0x03,
    0x55, 0x1d, 0x0f, 0x01, 0x01, 0xff, 0x04, 0x04, 0x03, 0x02, 0x07, 0x80, 0x30, 0x20, 0x06, 0x03, 0x55, 0x1d, 0x25, 0x01, 0x01,
    0xff, 0x04, 0x16, 0x30, 0x14, 0x06, 0x08, 0x2b, 0x06, 0x01, 0x05, 0x05, 0x07, 0x03, 0x02, 0x06, 0x08, 0x2b, 0x06, 0x01, 0x05,
    0x05, 0x07, 0x03, 0x01, 0x30, 0x1d, 0x06, 0x03, 0x55, 0x1d, 0x0e, 0x04, 0x16, 0x04, 0x14, 0x44, 0xfa, 0x8c, 0x5f, 0x32, 0xee,
    0x1f, 0xfc, 0x9d, 0x98, 0x1f, 0x90, 0xab, 0x2e, 0xcc, 0xd0, 0x65, 0xac, 0xed, 0x05, 0x30, 0x1f, 0x06, 0x03, 0x55, 0x1d, 0x23,
    0x04, 0x18, 0x30, 0x16, 0x80, 0x14, 0xcf, 0x42, 0xbc, 0xf8, 0xdf, 0x48, 0x09, 0xd9, 0x26, 0x6f, 0x23, 0x15, 0x5a, 0x16, 0xb0,
    0x7f, 0x04, 0xbb, 0x3d, 0x84, 0x30, 0x0a, 0x06, 0x08, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x04, 0x03, 0x02, 0x03, 0x48, 0x00, 0x30,
    0x45, 0x02, 0x20, 0x58, 0x80, 0xe4, 0x98, 0x79, 0x04, 0x6e, 0xc1, 0x08, 0x51, 0x38, 0xfd, 0x42, 0xc7, 0x48, 0x8d, 0xfc, 0xa1,
    0xaa, 0xaa, 0x81, 0xd8, 0x37, 0x87, 0xa2, 0xee, 0x2a, 0x65, 0xd9, 0xf2, 0x4f, 0x09, 0x02, 0x21, 0x00, 0x91, 0x85, 0x9a, 0x9d,
    0x2d, 0x08, 0x0d, 0x9b, 0x0b, 0x14, 0xa2, 0x28, 0x99, 0xf1, 0xfb, 0xc2, 0x52, 0xcf, 0x52, 0x94, 0xa0, 0xbe, 0x8f, 0x3c, 0xe5,
    0xbb, 0x22, 0x58, 0x7b, 0x9a, 0xc2, 0xb4,
};

extern const uint32_t sTestCert_Node02_04_DER_Len = sizeof(sTestCert_Node02_04_DER);

extern const uint8_t sTestCert_Node02_04_PublicKey[] = {
    0x04, 0x58, 0xeb, 0x6f, 0xa0, 0x34, 0x4a, 0x08, 0x45, 0xaf, 0xcf, 0xd6, 0xcf, 0x31, 0xfe, 0x5e, 0x92,
    0x27, 0x4e, 0xb6, 0x31, 0xea, 0xad, 0xab, 0xa3, 0x4b, 0x84, 0xee, 0x8d, 0x01, 0x6e, 0xe2, 0x57, 0xd5,
    0x37, 0x4f, 0xbe, 0xa8, 0x04, 0x86, 0xd3, 0xd9, 0x3f, 0x15, 0x1c, 0x3f, 0xea, 0x24, 0x25, 0xa6, 0xf4,
    0x57, 0xb1, 0xb7, 0x87, 0x79, 0x9f, 0x4b, 0xa8, 0x24, 0x01, 0x00, 0x99, 0xf8, 0x8c,
};

extern const uint8_t sTestCert_Node02_04_PublicKey_Len = sizeof(sTestCert_Node02_04_PublicKey);

extern const uint8_t sTestCert_Node02_04_PrivateKey[] = {
    0x47, 0x48, 0x61, 0x86, 0x16, 0xb2, 0x94, 0xd4, 0x37, 0xc0, 0xa7, 0x4d, 0x74, 0x1c, 0x29, 0x7f,
    0x9b, 0x20, 0x34, 0x03, 0xee, 0x7b, 0x3e, 0xa2, 0xb5, 0x2e, 0x25, 0xda, 0xf1, 0x68, 0x2f, 0x70,
};

extern const uint8_t sTestCert_Node02_04_PrivateKey_Len = sizeof(sTestCert_Node02_04_PrivateKey);

extern const uint8_t sTestCert_Node02_04_SubjectKeyId[] = {
    0x44, 0xFA, 0x8C, 0x5F, 0x32, 0xEE, 0x1F, 0xFC, 0x9D, 0x98, 0x1F, 0x90, 0xAB, 0x2E, 0xCC, 0xD0, 0x65, 0xAC, 0xED, 0x05,
};

extern const uint8_t sTestCert_Node02_04_SubjectKeyId_Len = sizeof(sTestCert_Node02_04_SubjectKeyId);

/**************  Test Node02_05 Certificate  **************
Certificate:
    Data:
        Version: 3 (0x2)
        Serial Number: 3019599144066184987 (0x29e7c56c4a23771b)
        Signature Algorithm: ecdsa-with-SHA256
        Issuer: 1.3.6.1.4.1.37244.1.3 = CACACACA00000004, 1.3.6.1.4.1.37244.1.5 = FAB000000000001D
        Validity
            Not Before: Oct 15 14:23:43 2020 GMT
            Not After : Oct 15 14:23:42 2040 GMT
        Subject: 1.3.6.1.4.1.37244.1.6 = A001B001, 1.3.6.1.4.1.37244.1.5 = FAB000000000001D, 1.3.6.1.4.1.37244.1.7 =
A001B002, 1.3.6.1.4.1.37244.1.1 = DEDEDEDE00020005 Subject Public Key Info: Public Key Algorithm: id-ecPublicKey Public-Key: (256
bit) pub: 04:c3:85:f5:b5:79:09:ea:91:d2:08:45:f8:1b:e1: 01:10:36:93:60:f7:dc:25:80:22:91:6d:0e:55:39:
                    b2:47:78:2d:fa:f0:1c:61:f8:eb:1b:f4:90:3f:81:
                    47:e0:a4:2f:a7:0f:46:6e:c9:52:7f:99:95:02:94:
                    7a:44:9d:eb:f7
                ASN1 OID: prime256v1
                NIST CURVE: P-256
        X509v3 extensions:
            X509v3 Basic Constraints: critical
                CA:FALSE
            X509v3 Key Usage: critical
                Digital Signature
            X509v3 Extended Key Usage: critical
                TLS Web Client Authentication, TLS Web Server Authentication
            X509v3 Subject Key Identifier:
                CB:8E:1D:22:39:40:B9:B6:01:0B:A7:58:96:E1:1D:7A:3E:09:6A:72
            X509v3 Authority Key Identifier:
                keyid:CF:42:BC:F8:DF:48:09:D9:26:6F:23:15:5A:16:B0:7F:04:BB:3D:84

            X509v3 Subject Alternative Name:
                email:test@chip.org
    Signature Algorithm: ecdsa-with-SHA256
         30:44:02:20:5a:8f:f8:2a:9c:a9:24:24:89:0d:5d:71:4a:1d:
         ab:05:94:cb:8d:6a:b0:36:55:c8:cb:d5:1d:68:29:8c:d8:09:
         02:20:15:71:fb:40:95:5a:22:64:b9:ad:86:d8:94:b4:06:a0:
         46:ef:80:b8:c2:c5:8d:a9:b0:17:20:0f:68:b0:6f:14

-----BEGIN CERTIFICATE-----
MIICTzCCAfagAwIBAgIIKefFbEojdxswCgYIKoZIzj0EAwIwRDEgMB4GCisGAQQB
gqJ8AQMMEENBQ0FDQUNBMDAwMDAwMDQxIDAeBgorBgEEAYKifAEFDBBGQUIwMDAw
MDAwMDAwMDFEMB4XDTIwMTAxNTE0MjM0M1oXDTQwMTAxNTE0MjM0MloweDEYMBYG
CisGAQQBgqJ8AQYMCEEwMDFCMDAxMSAwHgYKKwYBBAGConwBBQwQRkFCMDAwMDAw
MDAwMDAxRDEYMBYGCisGAQQBgqJ8AQcMCEEwMDFCMDAyMSAwHgYKKwYBBAGConwB
AQwQREVERURFREUwMDAyMDAwNTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABMOF
9bV5CeqR0ghF+BvhARA2k2D33CWAIpFtDlU5skd4LfrwHGH46xv0kD+BR+CkL6cP
Rm7JUn+ZlQKUekSd6/ejgZ0wgZowDAYDVR0TAQH/BAIwADAOBgNVHQ8BAf8EBAMC
B4AwIAYDVR0lAQH/BBYwFAYIKwYBBQUHAwIGCCsGAQUFBwMBMB0GA1UdDgQWBBTL
jh0iOUC5tgELp1iW4R16PglqcjAfBgNVHSMEGDAWgBTPQrz430gJ2SZvIxVaFrB/
BLs9hDAYBgNVHREEETAPgQ10ZXN0QGNoaXAub3JnMAoGCCqGSM49BAMCA0cAMEQC
IFqP+CqcqSQkiQ1dcUodqwWUy41qsDZVyMvVHWgpjNgJAiAVcftAlVoiZLmthtiU
tAagRu+AuMLFjamwFyAPaLBvFA==
-----END CERTIFICATE-----

-----BEGIN EC PRIVATE KEY-----
MHcCAQEEIAEEHAsipLqjBG+pRUt2CHzOTKFWjf5JwJtpj9GA+HstoAoGCCqGSM49
AwEHoUQDQgAEw4X1tXkJ6pHSCEX4G+EBEDaTYPfcJYAikW0OVTmyR3gt+vAcYfjr
G/SQP4FH4KQvpw9GbslSf5mVApR6RJ3r9w==
-----END EC PRIVATE KEY-----
*/

extern const uint8_t sTestCert_Node02_05_Chip[] = {
    0x15, 0x30, 0x01, 0x08, 0x29, 0xe7, 0xc5, 0x6c, 0x4a, 0x23, 0x77, 0x1b, 0x24, 0x02, 0x01, 0x37, 0x03, 0x27, 0x13, 0x04,
    0x00, 0x00, 0x00, 0xca, 0xca, 0xca, 0xca, 0x27, 0x15, 0x1d, 0x00, 0x00, 0x00, 0x00, 0x00, 0xb0, 0xfa, 0x18, 0x26, 0x04,
    0xef, 0x17, 0x1b, 0x27, 0x26, 0x05, 0x6e, 0xb5, 0xb9, 0x4c, 0x37, 0x06, 0x26, 0x16, 0x01, 0xb0, 0x01, 0xa0, 0x27, 0x15,
    0x1d, 0x00, 0x00, 0x00, 0x00, 0x00, 0xb0, 0xfa, 0x26, 0x17, 0x02, 0xb0, 0x01, 0xa0, 0x27, 0x11, 0x05, 0x00, 0x02, 0x00,
    0xde, 0xde, 0xde, 0xde, 0x18, 0x24, 0x07, 0x01, 0x24, 0x08, 0x01, 0x30, 0x09, 0x41, 0x04, 0xc3, 0x85, 0xf5, 0xb5, 0x79,
    0x09, 0xea, 0x91, 0xd2, 0x08, 0x45, 0xf8, 0x1b, 0xe1, 0x01, 0x10, 0x36, 0x93, 0x60, 0xf7, 0xdc, 0x25, 0x80, 0x22, 0x91,
    0x6d, 0x0e, 0x55, 0x39, 0xb2, 0x47, 0x78, 0x2d, 0xfa, 0xf0, 0x1c, 0x61, 0xf8, 0xeb, 0x1b, 0xf4, 0x90, 0x3f, 0x81, 0x47,
    0xe0, 0xa4, 0x2f, 0xa7, 0x0f, 0x46, 0x6e, 0xc9, 0x52, 0x7f, 0x99, 0x95, 0x02, 0x94, 0x7a, 0x44, 0x9d, 0xeb, 0xf7, 0x37,
    0x0a, 0x35, 0x01, 0x28, 0x01, 0x18, 0x24, 0x02, 0x01, 0x36, 0x03, 0x04, 0x02, 0x04, 0x01, 0x18, 0x30, 0x04, 0x14, 0xcb,
    0x8e, 0x1d, 0x22, 0x39, 0x40, 0xb9, 0xb6, 0x01, 0x0b, 0xa7, 0x58, 0x96, 0xe1, 0x1d, 0x7a, 0x3e, 0x09, 0x6a, 0x72, 0x30,
    0x05, 0x14, 0xcf, 0x42, 0xbc, 0xf8, 0xdf, 0x48, 0x09, 0xd9, 0x26, 0x6f, 0x23, 0x15, 0x5a, 0x16, 0xb0, 0x7f, 0x04, 0xbb,
    0x3d, 0x84, 0x30, 0x06, 0x1a, 0x30, 0x18, 0x06, 0x03, 0x55, 0x1d, 0x11, 0x04, 0x11, 0x30, 0x0f, 0x81, 0x0d, 0x74, 0x65,
    0x73, 0x74, 0x40, 0x63, 0x68, 0x69, 0x70, 0x2e, 0x6f, 0x72, 0x67, 0x18, 0x30, 0x0b, 0x40, 0x5a, 0x8f, 0xf8, 0x2a, 0x9c,
    0xa9, 0x24, 0x24, 0x89, 0x0d, 0x5d, 0x71, 0x4a, 0x1d, 0xab, 0x05, 0x94, 0xcb, 0x8d, 0x6a, 0xb0, 0x36, 0x55, 0xc8, 0xcb,
    0xd5, 0x1d, 0x68, 0x29, 0x8c, 0xd8, 0x09, 0x15, 0x71, 0xfb, 0x40, 0x95, 0x5a, 0x22, 0x64, 0xb9, 0xad, 0x86, 0xd8, 0x94,
    0xb4, 0x06, 0xa0, 0x46, 0xef, 0x80, 0xb8, 0xc2, 0xc5, 0x8d, 0xa9, 0xb0, 0x17, 0x20, 0x0f, 0x68, 0xb0, 0x6f, 0x14, 0x18,
};

extern const uint32_t sTestCert_Node02_05_Chip_Len = sizeof(sTestCert_Node02_05_Chip);

extern const uint8_t sTestCert_Node02_05_DER[] = {
    0x30, 0x82, 0x02, 0x4f, 0x30, 0x82, 0x01, 0xf6, 0xa0, 0x03, 0x02, 0x01, 0x02, 0x02, 0x08, 0x29, 0xe7, 0xc5, 0x6c, 0x4a, 0x23,
    0x77, 0x1b, 0x30, 0x0a, 0x06, 0x08, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x04, 0x03, 0x02, 0x30, 0x44, 0x31, 0x20, 0x30, 0x1e, 0x06,
    0x0a, 0x2b, 0x06, 0x01, 0x04, 0x01, 0x82, 0xa2, 0x7c, 0x01, 0x03, 0x0c, 0x10, 0x43, 0x41, 0x43, 0x41, 0x43, 0x41, 0x43, 0x41,
    0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x31, 0x20, 0x30, 0x1e, 0x06, 0x0a, 0x2b, 0x06, 0x01, 0x04, 0x01, 0x82, 0xa2,
    0x7c, 0x01, 0x05, 0x0c, 0x10, 0x46, 0x41, 0x42, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x44,
    0x30, 0x1e, 0x17, 0x0d, 0x32, 0x30, 0x31, 0x30, 0x31, 0x35, 0x31, 0x34, 0x32, 0x33, 0x34, 0x33, 0x5a, 0x17, 0x0d, 0x34, 0x30,
    0x31, 0x30, 0x31, 0x35, 0x31, 0x34, 0x32, 0x33, 0x34, 0x32, 0x5a, 0x30, 0x78, 0x31, 0x18, 0x30, 0x16, 0x06, 0x0a, 0x2b, 0x06,
    0x01, 0x04, 0x01, 0x82, 0xa2, 0x7c, 0x01, 0x06, 0x0c, 0x08, 0x41, 0x30, 0x30, 0x31, 0x42, 0x30, 0x30, 0x31, 0x31, 0x20, 0x30,
    0x1e, 0x06, 0x0a, 0x2b, 0x06, 0x01, 0x04, 0x01, 0x82, 0xa2, 0x7c, 0x01, 0x05, 0x0c, 0x10, 0x46, 0x41, 0x42, 0x30, 0x30, 0x30,
    0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x44, 0x31, 0x18, 0x30, 0x16, 0x06, 0x0a, 0x2b, 0x06, 0x01, 0x04, 0x01,
    0x82, 0xa2, 0x7c, 0x01, 0x07, 0x0c, 0x08, 0x41, 0x30, 0x30, 0x31, 0x42, 0x30, 0x30, 0x32, 0x31, 0x20, 0x30, 0x1e, 0x06, 0x0a,
    0x2b, 0x06, 0x01, 0x04, 0x01, 0x82, 0xa2, 0x7c, 0x01, 0x01, 0x0c, 0x10, 0x44, 0x45, 0x44, 0x45, 0x44, 0x45, 0x44, 0x45, 0x30,
    0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x35, 0x30, 0x59, 0x30, 0x13, 0x06, 0x07, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x02, 0x01, 0x06,
    0x08, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x03, 0x01, 0x07, 0x03, 0x42, 0x00, 0x04, 0xc3, 0x85, 0xf5, 0xb5, 0x79, 0x09, 0xea, 0x91,
    0xd2, 0x08, 0x45, 0xf8, 0x1b, 0xe1, 0x01, 0x10, 0x36, 0x93, 0x60, 0xf7, 0xdc, 0x25, 0x80, 0x22, 0x91, 0x6d, 0x0e, 0x55, 0x39,
    0xb2, 0x47, 0x78, 0x2d, 0xfa, 0xf0, 0x1c, 0x61, 0xf8, 0xeb, 0x1b, 0xf4, 0x90, 0x3f, 0x81, 0x47, 0xe0, 0xa4, 0x2f, 0xa7, 0x0f,
    0x46, 0x6e, 0xc9, 0x52, 0x7f, 0x99, 0x95, 0x02, 0x94, 0x7a, 0x44, 0x9d, 0xeb, 0xf7, 0xa3, 0x81, 0x9d, 0x30, 0x81, 0x9a, 0x30,
    0x0c, 0x06, 0x03, 0x55, 0x1d, 0x13, 0x01, 0x01, 0xff, 0x04, 0x02, 0x30, 0x00, 0x30, 0x0e, 0x06, 0x03, 0x55, 0x1d, 0x0f, 0x01,
    0x01, 0xff, 0x04, 0x04, 0x03, 0x02, 0x07, 0x80, 0x30, 0x20, 0x06, 0x03, 0x55, 0x1d, 0x25, 0x01, 0x01, 0xff, 0x04, 0x16, 0x30,
    0x14, 0x06, 0x08, 0x2b, 0x06, 0x01, 0x05, 0x05, 0x07, 0x03, 0x02, 0x06, 0x08, 0x2b, 0x06, 0x01, 0x05, 0x05, 0x07, 0x03, 0x01,
    0x30, 0x1d, 0x06, 0x03, 0x55, 0x1d, 0x0e, 0x04, 0x16, 0x04, 0x14, 0xcb, 0x8e, 0x1d, 0x22, 0x39, 0x40, 0xb9, 0xb6, 0x01, 0x0b,
    0xa7, 0x58, 0x96, 0xe1, 0x1d, 0x7a, 0x3e, 0x09, 0x6a, 0x72, 0x30, 0x1f, 0x06, 0x03, 0x55, 0x1d, 0x23, 0x04, 0x18, 0x30, 0x16,
    0x80, 0x14, 0xcf, 0x42, 0xbc, 0xf8, 0xdf, 0x48, 0x09, 0xd9, 0x26, 0x6f, 0x23, 0x15, 0x5a, 0x16, 0xb0, 0x7f, 0x04, 0xbb, 0x3d,
    0x84, 0x30, 0x18, 0x06, 0x03, 0x55, 0x1d, 0x11, 0x04, 0x11, 0x30, 0x0f, 0x81, 0x0d, 0x74, 0x65, 0x73, 0x74, 0x40, 0x63, 0x68,
    0x69, 0x70, 0x2e, 0x6f, 0x72, 0x67, 0x30, 0x0a, 0x06, 0x08, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x04, 0x03, 0x02, 0x03, 0x47, 0x00,
    0x30, 0x44, 0x02, 0x20, 0x5a, 0x8f, 0xf8, 0x2a, 0x9c, 0xa9, 0x24, 0x24, 0x89, 0x0d, 0x5d, 0x71, 0x4a, 0x1d, 0xab, 0x05, 0x94,
    0xcb, 0x8d, 0x6a, 0xb0, 0x36, 0x55, 0xc8, 0xcb, 0xd5, 0x1d, 0x68, 0x29, 0x8c, 0xd8, 0x09, 0x02, 0x20, 0x15, 0x71, 0xfb, 0x40,
    0x95, 0x5a, 0x22, 0x64, 0xb9, 0xad, 0x86, 0xd8, 0x94, 0xb4, 0x06, 0xa0, 0x46, 0xef, 0x80, 0xb8, 0xc2, 0xc5, 0x8d, 0xa9, 0xb0,
    0x17, 0x20, 0x0f, 0x68, 0xb0, 0x6f, 0x14,
};

extern const uint32_t sTestCert_Node02_05_DER_Len = sizeof(sTestCert_Node02_05_DER);

extern const uint8_t sTestCert_Node02_05_PublicKey[] = {
    0x04, 0xc3, 0x85, 0xf5, 0xb5, 0x79, 0x09, 0xea, 0x91, 0xd2, 0x08, 0x45, 0xf8, 0x1b, 0xe1, 0x01, 0x10,
    0x36, 0x93, 0x60, 0xf7, 0xdc, 0x25, 0x80, 0x22, 0x91, 0x6d, 0x0e, 0x55, 0x39, 0xb2, 0x47, 0x78, 0x2d,
    0xfa, 0xf0, 0x1c, 0x61, 0xf8, 0xeb, 0x1b, 0xf4, 0x90, 0x3f, 0x81, 0x47, 0xe0, 0xa4, 0x2f, 0xa7, 0x0f,
    0x46, 0x6e, 0xc9, 0x52, 0x7f, 0x99, 0x95, 0x02, 0x94, 0x7a, 0x44, 0x9d, 0xeb, 0xf7,
};

extern const uint8_t sTestCert_Node02_05_PublicKey_Len = sizeof(sTestCert_Node02_05_PublicKey);

extern const uint8_t sTestCert_Node02_05_PrivateKey[] = {
    0x01, 0x04, 0x1c, 0x0b, 0x22, 0xa4, 0xba, 0xa3, 0x04, 0x6f, 0xa9, 0x45, 0x4b, 0x76, 0x08, 0x7c,
    0xce, 0x4c, 0xa1, 0x56, 0x8d, 0xfe, 0x49, 0xc0, 0x9b, 0x69, 0x8f, 0xd1, 0x80, 0xf8, 0x7b, 0x2d,
};

extern const uint8_t sTestCert_Node02_05_PrivateKey_Len = sizeof(sTestCert_Node02_05_PrivateKey);

extern const uint8_t sTestCert_Node02_05_SubjectKeyId[] = {
    0xCB, 0x8E, 0x1D, 0x22, 0x39, 0x40, 0xB9, 0xB6, 0x01, 0x0B, 0xA7, 0x58, 0x96, 0xE1, 0x1D, 0x7A, 0x3E, 0x09, 0x6A, 0x72,
};

extern const uint8_t sTestCert_Node02_05_SubjectKeyId_Len = sizeof(sTestCert_Node02_05_SubjectKeyId);

/**************  Test Node02_06 Certificate  **************
Certificate:
    Data:
        Version: 3 (0x2)
        Serial Number: 7516176295543836038 (0x684ed284b51a0d86)
        Signature Algorithm: ecdsa-with-SHA256
        Issuer: 1.3.6.1.4.1.37244.1.3 = CACACACA00000004, 1.3.6.1.4.1.37244.1.5 = FAB000000000001D
        Validity
            Not Before: Oct 15 14:23:43 2020 GMT
            Not After : Oct 15 14:23:42 2040 GMT
        Subject: 1.3.6.1.4.1.37244.1.1 = DEDEDEDE00020006, 1.3.6.1.4.1.37244.1.5 = FAB000000000001D
        Subject Public Key Info:
            Public Key Algorithm: id-ecPublicKey
                Public-Key: (256 bit)
                pub:
                    04:9f:7b:6e:a3:42:a5:02:10:da:1d:fa:ff:ba:ca:
                    6b:70:11:c0:2a:7f:ac:39:73:bd:d3:06:24:c9:c7:
                    09:6c:cb:97:fa:26:cb:50:ff:83:4e:f2:4a:d8:9e:
                    80:45:94:5f:dd:d0:40:0b:45:98:17:3f:d7:5b:a0:
                    b2:f4:43:27:32
                ASN1 OID: prime256v1
                NIST CURVE: P-256
        X509v3 extensions:
            X509v3 Basic Constraints: critical
                CA:FALSE
            X509v3 Key Usage: critical
                Digital Signature
            X509v3 Extended Key Usage: critical
                TLS Web Client Authentication, TLS Web Server Authentication
            X509v3 Subject Key Identifier:
                AB:89:94:81:DD:06:D6:22:A0:13:C8:BA:7D:95:C4:8D:B9:7E:5B:2F
            X509v3 Authority Key Identifier:
                keyid:CF:42:BC:F8:DF:48:09:D9:26:6F:23:15:5A:16:B0:7F:04:BB:3D:84

            X509v3 Subject Alternative Name:
                email:test@chip.org
            Authority Information Access:
                OCSP - URI:test

    Signature Algorithm: ecdsa-with-SHA256
         30:46:02:21:00:e2:9a:0e:bd:45:be:4f:52:bd:83:ca:06:97:
         15:ed:08:37:f6:25:82:c0:02:26:28:57:b2:f2:2f:9d:b1:e1:
         24:02:21:00:d9:0a:da:e9:11:80:79:72:f2:f3:74:4e:29:95:
         d4:f8:bf:19:f9:d4:3f:cd:a6:3d:28:56:6f:87:ce:3d:af:b4

-----BEGIN CERTIFICATE-----
MIICPzCCAeSgAwIBAgIIaE7ShLUaDYYwCgYIKoZIzj0EAwIwRDEgMB4GCisGAQQB
gqJ8AQMMEENBQ0FDQUNBMDAwMDAwMDQxIDAeBgorBgEEAYKifAEFDBBGQUIwMDAw
MDAwMDAwMDFEMB4XDTIwMTAxNTE0MjM0M1oXDTQwMTAxNTE0MjM0MlowRDEgMB4G
CisGAQQBgqJ8AQEMEERFREVERURFMDAwMjAwMDYxIDAeBgorBgEEAYKifAEFDBBG
QUIwMDAwMDAwMDAwMDFEMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEn3tuo0Kl
AhDaHfr/usprcBHAKn+sOXO90wYkyccJbMuX+ibLUP+DTvJK2J6ARZRf3dBAC0WY
Fz/XW6Cy9EMnMqOBvzCBvDAMBgNVHRMBAf8EAjAAMA4GA1UdDwEB/wQEAwIHgDAg
BgNVHSUBAf8EFjAUBggrBgEFBQcDAgYIKwYBBQUHAwEwHQYDVR0OBBYEFKuJlIHd
BtYioBPIun2VxI25flsvMB8GA1UdIwQYMBaAFM9CvPjfSAnZJm8jFVoWsH8Euz2E
MBgGA1UdEQQRMA+BDXRlc3RAY2hpcC5vcmcwIAYIKwYBBQUHAQEEFDASMBAGCCsG
AQUFBzABhgR0ZXN0MAoGCCqGSM49BAMCA0kAMEYCIQDimg69Rb5PUr2DygaXFe0I
N/YlgsACJihXsvIvnbHhJAIhANkK2ukRgHly8vN0TimV1Pi/GfnUP82mPShWb4fO
Pa+0
-----END CERTIFICATE-----

-----BEGIN EC PRIVATE KEY-----
MHcCAQEEIPFqxUaZp1qy8/ksS24zQxPx+CpB4mOkSyQEeX9auRcUoAoGCCqGSM49
AwEHoUQDQgAEn3tuo0KlAhDaHfr/usprcBHAKn+sOXO90wYkyccJbMuX+ibLUP+D
TvJK2J6ARZRf3dBAC0WYFz/XW6Cy9EMnMg==
-----END EC PRIVATE KEY-----
*/

extern const uint8_t sTestCert_Node02_06_Chip[] = {
    0x15, 0x30, 0x01, 0x08, 0x68, 0x4e, 0xd2, 0x84, 0xb5, 0x1a, 0x0d, 0x86, 0x24, 0x02, 0x01, 0x37, 0x03, 0x27, 0x13, 0x04, 0x00,
    0x00, 0x00, 0xca, 0xca, 0xca, 0xca, 0x27, 0x15, 0x1d, 0x00, 0x00, 0x00, 0x00, 0x00, 0xb0, 0xfa, 0x18, 0x26, 0x04, 0xef, 0x17,
    0x1b, 0x27, 0x26, 0x05, 0x6e, 0xb5, 0xb9, 0x4c, 0x37, 0x06, 0x27, 0x11, 0x06, 0x00, 0x02, 0x00, 0xde, 0xde, 0xde, 0xde, 0x27,
    0x15, 0x1d, 0x00, 0x00, 0x00, 0x00, 0x00, 0xb0, 0xfa, 0x18, 0x24, 0x07, 0x01, 0x24, 0x08, 0x01, 0x30, 0x09, 0x41, 0x04, 0x9f,
    0x7b, 0x6e, 0xa3, 0x42, 0xa5, 0x02, 0x10, 0xda, 0x1d, 0xfa, 0xff, 0xba, 0xca, 0x6b, 0x70, 0x11, 0xc0, 0x2a, 0x7f, 0xac, 0x39,
    0x73, 0xbd, 0xd3, 0x06, 0x24, 0xc9, 0xc7, 0x09, 0x6c, 0xcb, 0x97, 0xfa, 0x26, 0xcb, 0x50, 0xff, 0x83, 0x4e, 0xf2, 0x4a, 0xd8,
    0x9e, 0x80, 0x45, 0x94, 0x5f, 0xdd, 0xd0, 0x40, 0x0b, 0x45, 0x98, 0x17, 0x3f, 0xd7, 0x5b, 0xa0, 0xb2, 0xf4, 0x43, 0x27, 0x32,
    0x37, 0x0a, 0x35, 0x01, 0x28, 0x01, 0x18, 0x24, 0x02, 0x01, 0x36, 0x03, 0x04, 0x02, 0x04, 0x01, 0x18, 0x30, 0x04, 0x14, 0xab,
    0x89, 0x94, 0x81, 0xdd, 0x06, 0xd6, 0x22, 0xa0, 0x13, 0xc8, 0xba, 0x7d, 0x95, 0xc4, 0x8d, 0xb9, 0x7e, 0x5b, 0x2f, 0x30, 0x05,
    0x14, 0xcf, 0x42, 0xbc, 0xf8, 0xdf, 0x48, 0x09, 0xd9, 0x26, 0x6f, 0x23, 0x15, 0x5a, 0x16, 0xb0, 0x7f, 0x04, 0xbb, 0x3d, 0x84,
    0x30, 0x06, 0x1a, 0x30, 0x18, 0x06, 0x03, 0x55, 0x1d, 0x11, 0x04, 0x11, 0x30, 0x0f, 0x81, 0x0d, 0x74, 0x65, 0x73, 0x74, 0x40,
    0x63, 0x68, 0x69, 0x70, 0x2e, 0x6f, 0x72, 0x67, 0x30, 0x06, 0x22, 0x30, 0x20, 0x06, 0x08, 0x2b, 0x06, 0x01, 0x05, 0x05, 0x07,
    0x01, 0x01, 0x04, 0x14, 0x30, 0x12, 0x30, 0x10, 0x06, 0x08, 0x2b, 0x06, 0x01, 0x05, 0x05, 0x07, 0x30, 0x01, 0x86, 0x04, 0x74,
    0x65, 0x73, 0x74, 0x18, 0x30, 0x0b, 0x40, 0xe2, 0x9a, 0x0e, 0xbd, 0x45, 0xbe, 0x4f, 0x52, 0xbd, 0x83, 0xca, 0x06, 0x97, 0x15,
    0xed, 0x08, 0x37, 0xf6, 0x25, 0x82, 0xc0, 0x02, 0x26, 0x28, 0x57, 0xb2, 0xf2, 0x2f, 0x9d, 0xb1, 0xe1, 0x24, 0xd9, 0x0a, 0xda,
    0xe9, 0x11, 0x80, 0x79, 0x72, 0xf2, 0xf3, 0x74, 0x4e, 0x29, 0x95, 0xd4, 0xf8, 0xbf, 0x19, 0xf9, 0xd4, 0x3f, 0xcd, 0xa6, 0x3d,
    0x28, 0x56, 0x6f, 0x87, 0xce, 0x3d, 0xaf, 0xb4, 0x18,
};

extern const uint32_t sTestCert_Node02_06_Chip_Len = sizeof(sTestCert_Node02_06_Chip);

extern const uint8_t sTestCert_Node02_06_DER[] = {
    0x30, 0x82, 0x02, 0x3f, 0x30, 0x82, 0x01, 0xe4, 0xa0, 0x03, 0x02, 0x01, 0x02, 0x02, 0x08, 0x68, 0x4e, 0xd2, 0x84, 0xb5, 0x1a,
    0x0d, 0x86, 0x30, 0x0a, 0x06, 0x08, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x04, 0x03, 0x02, 0x30, 0x44, 0x31, 0x20, 0x30, 0x1e, 0x06,
    0x0a, 0x2b, 0x06, 0x01, 0x04, 0x01, 0x82, 0xa2, 0x7c, 0x01, 0x03, 0x0c, 0x10, 0x43, 0x41, 0x43, 0x41, 0x43, 0x41, 0x43, 0x41,
    0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x31, 0x20, 0x30, 0x1e, 0x06, 0x0a, 0x2b, 0x06, 0x01, 0x04, 0x01, 0x82, 0xa2,
    0x7c, 0x01, 0x05, 0x0c, 0x10, 0x46, 0x41, 0x42, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x44,
    0x30, 0x1e, 0x17, 0x0d, 0x32, 0x30, 0x31, 0x30, 0x31, 0x35, 0x31, 0x34, 0x32, 0x33, 0x34, 0x33, 0x5a, 0x17, 0x0d, 0x34, 0x30,
    0x31, 0x30, 0x31, 0x35, 0x31, 0x34, 0x32, 0x33, 0x34, 0x32, 0x5a, 0x30, 0x44, 0x31, 0x20, 0x30, 0x1e, 0x06, 0x0a, 0x2b, 0x06,
    0x01, 0x04, 0x01, 0x82, 0xa2, 0x7c, 0x01, 0x01, 0x0c, 0x10, 0x44, 0x45, 0x44, 0x45, 0x44, 0x45, 0x44, 0x45, 0x30, 0x30, 0x30,
    0x32, 0x30, 0x30, 0x30, 0x36, 0x31, 0x20, 0x30, 0x1e, 0x06, 0x0a, 0x2b, 0x06, 0x01, 0x04, 0x01, 0x82, 0xa2, 0x7c, 0x01, 0x05,
    0x0c, 0x10, 0x46, 0x41, 0x42, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x44, 0x30, 0x59, 0x30,
    0x13, 0x06, 0x07, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x02, 0x01, 0x06, 0x08, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x03, 0x01, 0x07, 0x03,
    0x42, 0x00, 0x04, 0x9f, 0x7b, 0x6e, 0xa3, 0x42, 0xa5, 0x02, 0x10, 0xda, 0x1d, 0xfa, 0xff, 0xba, 0xca, 0x6b, 0x70, 0x11, 0xc0,
    0x2a, 0x7f, 0xac, 0x39, 0x73, 0xbd, 0xd3, 0x06, 0x24, 0xc9, 0xc7, 0x09, 0x6c, 0xcb, 0x97, 0xfa, 0x26, 0xcb, 0x50, 0xff, 0x83,
    0x4e, 0xf2, 0x4a, 0xd8, 0x9e, 0x80, 0x45, 0x94, 0x5f, 0xdd, 0xd0, 0x40, 0x0b, 0x45, 0x98, 0x17, 0x3f, 0xd7, 0x5b, 0xa0, 0xb2,
    0xf4, 0x43, 0x27, 0x32, 0xa3, 0x81, 0xbf, 0x30, 0x81, 0xbc, 0x30, 0x0c, 0x06, 0x03, 0x55, 0x1d, 0x13, 0x01, 0x01, 0xff, 0x04,
    0x02, 0x30, 0x00, 0x30, 0x0e, 0x06, 0x03, 0x55, 0x1d, 0x0f, 0x01, 0x01, 0xff, 0x04, 0x04, 0x03, 0x02, 0x07, 0x80, 0x30, 0x20,
    0x06, 0x03, 0x55, 0x1d, 0x25, 0x01, 0x01, 0xff, 0x04, 0x16, 0x30, 0x14, 0x06, 0x08, 0x2b, 0x06, 0x01, 0x05, 0x05, 0x07, 0x03,
    0x02, 0x06, 0x08, 0x2b, 0x06, 0x01, 0x05, 0x05, 0x07, 0x03, 0x01, 0x30, 0x1d, 0x06, 0x03, 0x55, 0x1d, 0x0e, 0x04, 0x16, 0x04,
    0x14, 0xab, 0x89, 0x94, 0x81, 0xdd, 0x06, 0xd6, 0x22, 0xa0, 0x13, 0xc8, 0xba, 0x7d, 0x95, 0xc4, 0x8d, 0xb9, 0x7e, 0x5b, 0x2f,
    0x30, 0x1f, 0x06, 0x03, 0x55, 0x1d, 0x23, 0x04, 0x18, 0x30, 0x16, 0x80, 0x14, 0xcf, 0x42, 0xbc, 0xf8, 0xdf, 0x48, 0x09, 0xd9,
    0x26, 0x6f, 0x23, 0x15, 0x5a, 0x16, 0xb0, 0x7f, 0x04, 0xbb, 0x3d, 0x84, 0x30, 0x18, 0x06, 0x03, 0x55, 0x1d, 0x11, 0x04, 0x11,
    0x30, 0x0f, 0x81, 0x0d, 0x74, 0x65, 0x73, 0x74, 0x40, 0x63, 0x68, 0x69, 0x70, 0x2e, 0x6f, 0x72, 0x67, 0x30, 0x20, 0x06, 0x08,
    0x2b, 0x06, 0x01, 0x05, 0x05, 0x07, 0x01, 0x01, 0x04, 0x14, 0x30, 0x12, 0x30, 0x10, 0x06, 0x08, 0x2b, 0x06, 0x01, 0x05, 0x05,
    0x07, 0x30, 0x01, 0x86, 0x04, 0x74, 0x65, 0x73, 0x74, 0x30, 0x0a, 0x06, 0x08, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x04, 0x03, 0x02,
    0x03, 0x49, 0x00, 0x30, 0x46, 0x02, 0x21, 0x00, 0xe2, 0x9a, 0x0e, 0xbd, 0x45, 0xbe, 0x4f, 0x52, 0xbd, 0x83, 0xca, 0x06, 0x97,
    0x15, 0xed, 0x08, 0x37, 0xf6, 0x25, 0x82, 0xc0, 0x02, 0x26, 0x28, 0x57, 0xb2, 0xf2, 0x2f, 0x9d, 0xb1, 0xe1, 0x24, 0x02, 0x21,
    0x00, 0xd9, 0x0a, 0xda, 0xe9, 0x11, 0x80, 0x79, 0x72, 0xf2, 0xf3, 0x74, 0x4e, 0x29, 0x95, 0xd4, 0xf8, 0xbf, 0x19, 0xf9, 0xd4,
    0x3f, 0xcd, 0xa6, 0x3d, 0x28, 0x56, 0x6f, 0x87, 0xce, 0x3d, 0xaf, 0xb4,
};

extern const uint32_t sTestCert_Node02_06_DER_Len = sizeof(sTestCert_Node02_06_DER);

extern const uint8_t sTestCert_Node02_06_PublicKey[] = {
    0x04, 0x9f, 0x7b, 0x6e, 0xa3, 0x42, 0xa5, 0x02, 0x10, 0xda, 0x1d, 0xfa, 0xff, 0xba, 0xca, 0x6b, 0x70,
    0x11, 0xc0, 0x2a, 0x7f, 0xac, 0x39, 0x73, 0xbd, 0xd3, 0x06, 0x24, 0xc9, 0xc7, 0x09, 0x6c, 0xcb, 0x97,
    0xfa, 0x26, 0xcb, 0x50, 0xff, 0x83, 0x4e, 0xf2, 0x4a, 0xd8, 0x9e, 0x80, 0x45, 0x94, 0x5f, 0xdd, 0xd0,
    0x40, 0x0b, 0x45, 0x98, 0x17, 0x3f, 0xd7, 0x5b, 0xa0, 0xb2, 0xf4, 0x43, 0x27, 0x32,
};

extern const uint8_t sTestCert_Node02_06_PublicKey_Len = sizeof(sTestCert_Node02_06_PublicKey);

extern const uint8_t sTestCert_Node02_06_PrivateKey[] = {
    0xf1, 0x6a, 0xc5, 0x46, 0x99, 0xa7, 0x5a, 0xb2, 0xf3, 0xf9, 0x2c, 0x4b, 0x6e, 0x33, 0x43, 0x13,
    0xf1, 0xf8, 0x2a, 0x41, 0xe2, 0x63, 0xa4, 0x4b, 0x24, 0x04, 0x79, 0x7f, 0x5a, 0xb9, 0x17, 0x14,
};

extern const uint8_t sTestCert_Node02_06_PrivateKey_Len = sizeof(sTestCert_Node02_06_PrivateKey);

extern const uint8_t sTestCert_Node02_06_SubjectKeyId[] = {
    0xAB, 0x89, 0x94, 0x81, 0xDD, 0x06, 0xD6, 0x22, 0xA0, 0x13, 0xC8, 0xBA, 0x7D, 0x95, 0xC4, 0x8D, 0xB9, 0x7E, 0x5B, 0x2F,
};

extern const uint8_t sTestCert_Node02_06_SubjectKeyId_Len = sizeof(sTestCert_Node02_06_SubjectKeyId);

/**************  Test Node02_07 Certificate  **************
Certificate:
    Data:
        Version: 3 (0x2)
        Serial Number: 3033058160902015167 (0x2a179653d7aa08bf)
        Signature Algorithm: ecdsa-with-SHA256
        Issuer: 1.3.6.1.4.1.37244.1.3 = CACACACA00000004, 1.3.6.1.4.1.37244.1.5 = FAB000000000001D
        Validity
            Not Before: Oct 15 14:23:43 2020 GMT
            Not After : Oct 15 14:23:42 2040 GMT
        Subject: 1.3.6.1.4.1.37244.1.1 = DEDEDEDE00020007, 1.3.6.1.4.1.37244.1.5 = FAB000000000001D
        Subject Public Key Info:
            Public Key Algorithm: id-ecPublicKey
                Public-Key: (256 bit)
                pub:
                    04:f1:1b:05:37:f3:73:5c:dc:fa:c5:86:15:dd:1b:
                    13:4a:83:85:a4:75:15:58:fb:d1:fe:d2:55:93:35:
                    d0:c2:42:6f:60:08:f6:05:01:f6:44:a2:0a:8c:f9:
                    c4:1e:82:8c:38:a5:6f:56:88:d1:fa:af:d2:8b:21:
                    87:a8:f4:2e:74
                ASN1 OID: prime256v1
                NIST CURVE: P-256
        X509v3 extensions:
            X509v3 Basic Constraints: critical
                CA:FALSE
            X509v3 Key Usage: critical
                Digital Signature
            X509v3 Extended Key Usage: critical
                TLS Web Client Authentication, TLS Web Server Authentication
            X509v3 Subject Key Identifier:
                CB:58:71:E3:AD:6D:AB:0D:BF:29:A5:3C:AA:5B:99:1E:10:BE:71:98
            X509v3 Authority Key Identifier:
                keyid:CF:42:BC:F8:DF:48:09:D9:26:6F:23:15:5A:16:B0:7F:04:BB:3D:84

            X509v3 Subject Alternative Name: critical
                email:test@chip.org
            Authority Information Access:
                OCSP - URI:test

    Signature Algorithm: ecdsa-with-SHA256
         30:46:02:21:00:f1:10:28:aa:62:e4:e9:cd:ab:ab:c5:6c:79:
         c4:5c:4f:04:ad:c8:03:37:68:4c:ec:78:dc:86:0c:1b:e8:95:
         d2:02:21:00:8c:3b:50:55:63:ef:99:b2:98:2f:7b:ea:03:f3:
         21:56:ec:98:d0:e5:b8:bf:d1:45:52:04:52:c6:2a:63:c9:b2

-----BEGIN CERTIFICATE-----
MIICQjCCAeegAwIBAgIIKheWU9eqCL8wCgYIKoZIzj0EAwIwRDEgMB4GCisGAQQB
gqJ8AQMMEENBQ0FDQUNBMDAwMDAwMDQxIDAeBgorBgEEAYKifAEFDBBGQUIwMDAw
MDAwMDAwMDFEMB4XDTIwMTAxNTE0MjM0M1oXDTQwMTAxNTE0MjM0MlowRDEgMB4G
CisGAQQBgqJ8AQEMEERFREVERURFMDAwMjAwMDcxIDAeBgorBgEEAYKifAEFDBBG
QUIwMDAwMDAwMDAwMDFEMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE8RsFN/Nz
XNz6xYYV3RsTSoOFpHUVWPvR/tJVkzXQwkJvYAj2BQH2RKIKjPnEHoKMOKVvVojR
+q/SiyGHqPQudKOBwjCBvzAMBgNVHRMBAf8EAjAAMA4GA1UdDwEB/wQEAwIHgDAg
BgNVHSUBAf8EFjAUBggrBgEFBQcDAgYIKwYBBQUHAwEwHQYDVR0OBBYEFMtYceOt
basNvymlPKpbmR4QvnGYMB8GA1UdIwQYMBaAFM9CvPjfSAnZJm8jFVoWsH8Euz2E
MBsGA1UdEQEB/wQRMA+BDXRlc3RAY2hpcC5vcmcwIAYIKwYBBQUHAQEEFDASMBAG
CCsGAQUFBzABhgR0ZXN0MAoGCCqGSM49BAMCA0kAMEYCIQDxECiqYuTpzaurxWx5
xFxPBK3IAzdoTOx43IYMG+iV0gIhAIw7UFVj75mymC976gPzIVbsmNDluL/RRVIE
UsYqY8my
-----END CERTIFICATE-----

-----BEGIN EC PRIVATE KEY-----
MHcCAQEEIE2vFHuUml5s0sbXqnSmilEwpV/8aVmc04PA6K3ZpgfKoAoGCCqGSM49
AwEHoUQDQgAE8RsFN/NzXNz6xYYV3RsTSoOFpHUVWPvR/tJVkzXQwkJvYAj2BQH2
RKIKjPnEHoKMOKVvVojR+q/SiyGHqPQudA==
-----END EC PRIVATE KEY-----
*/

extern const uint8_t sTestCert_Node02_07_Chip[] = {
    0x15, 0x30, 0x01, 0x08, 0x2a, 0x17, 0x96, 0x53, 0xd7, 0xaa, 0x08, 0xbf, 0x24, 0x02, 0x01, 0x37, 0x03, 0x27, 0x13, 0x04, 0x00,
    0x00, 0x00, 0xca, 0xca, 0xca, 0xca, 0x27, 0x15, 0x1d, 0x00, 0x00, 0x00, 0x00, 0x00, 0xb0, 0xfa, 0x18, 0x26, 0x04, 0xef, 0x17,
    0x1b, 0x27, 0x26, 0x05, 0x6e, 0xb5, 0xb9, 0x4c, 0x37, 0x06, 0x27, 0x11, 0x07, 0x00, 0x02, 0x00, 0xde, 0xde, 0xde, 0xde, 0x27,
    0x15, 0x1d, 0x00, 0x00, 0x00, 0x00, 0x00, 0xb0, 0xfa, 0x18, 0x24, 0x07, 0x01, 0x24, 0x08, 0x01, 0x30, 0x09, 0x41, 0x04, 0xf1,
    0x1b, 0x05, 0x37, 0xf3, 0x73, 0x5c, 0xdc, 0xfa, 0xc5, 0x86, 0x15, 0xdd, 0x1b, 0x13, 0x4a, 0x83, 0x85, 0xa4, 0x75, 0x15, 0x58,
    0xfb, 0xd1, 0xfe, 0xd2, 0x55, 0x93, 0x35, 0xd0, 0xc2, 0x42, 0x6f, 0x60, 0x08, 0xf6, 0x05, 0x01, 0xf6, 0x44, 0xa2, 0x0a, 0x8c,
    0xf9, 0xc4, 0x1e, 0x82, 0x8c, 0x38, 0xa5, 0x6f, 0x56, 0x88, 0xd1, 0xfa, 0xaf, 0xd2, 0x8b, 0x21, 0x87, 0xa8, 0xf4, 0x2e, 0x74,
    0x37, 0x0a, 0x35, 0x01, 0x28, 0x01, 0x18, 0x24, 0x02, 0x01, 0x36, 0x03, 0x04, 0x02, 0x04, 0x01, 0x18, 0x30, 0x04, 0x14, 0xcb,
    0x58, 0x71, 0xe3, 0xad, 0x6d, 0xab, 0x0d, 0xbf, 0x29, 0xa5, 0x3c, 0xaa, 0x5b, 0x99, 0x1e, 0x10, 0xbe, 0x71, 0x98, 0x30, 0x05,
    0x14, 0xcf, 0x42, 0xbc, 0xf8, 0xdf, 0x48, 0x09, 0xd9, 0x26, 0x6f, 0x23, 0x15, 0x5a, 0x16, 0xb0, 0x7f, 0x04, 0xbb, 0x3d, 0x84,
    0x30, 0x06, 0x1d, 0x30, 0x1b, 0x06, 0x03, 0x55, 0x1d, 0x11, 0x01, 0x01, 0xff, 0x04, 0x11, 0x30, 0x0f, 0x81, 0x0d, 0x74, 0x65,
    0x73, 0x74, 0x40, 0x63, 0x68, 0x69, 0x70, 0x2e, 0x6f, 0x72, 0x67, 0x30, 0x06, 0x22, 0x30, 0x20, 0x06, 0x08, 0x2b, 0x06, 0x01,
    0x05, 0x05, 0x07, 0x01, 0x01, 0x04, 0x14, 0x30, 0x12, 0x30, 0x10, 0x06, 0x08, 0x2b, 0x06, 0x01, 0x05, 0x05, 0x07, 0x30, 0x01,
    0x86, 0x04, 0x74, 0x65, 0x73, 0x74, 0x18, 0x30, 0x0b, 0x40, 0xf1, 0x10, 0x28, 0xaa, 0x62, 0xe4, 0xe9, 0xcd, 0xab, 0xab, 0xc5,
    0x6c, 0x79, 0xc4, 0x5c, 0x4f, 0x04, 0xad, 0xc8, 0x03, 0x37, 0x68, 0x4c, 0xec, 0x78, 0xdc, 0x86, 0x0c, 0x1b, 0xe8, 0x95, 0xd2,
    0x8c, 0x3b, 0x50, 0x55, 0x63, 0xef, 0x99, 0xb2, 0x98, 0x2f, 0x7b, 0xea, 0x03, 0xf3, 0x21, 0x56, 0xec, 0x98, 0xd0, 0xe5, 0xb8,
    0xbf, 0xd1, 0x45, 0x52, 0x04, 0x52, 0xc6, 0x2a, 0x63, 0xc9, 0xb2, 0x18,
};

extern const uint32_t sTestCert_Node02_07_Chip_Len = sizeof(sTestCert_Node02_07_Chip);

extern const uint8_t sTestCert_Node02_07_DER[] = {
    0x30, 0x82, 0x02, 0x42, 0x30, 0x82, 0x01, 0xe7, 0xa0, 0x03, 0x02, 0x01, 0x02, 0x02, 0x08, 0x2a, 0x17, 0x96, 0x53, 0xd7, 0xaa,
    0x08, 0xbf, 0x30, 0x0a, 0x06, 0x08, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x04, 0x03, 0x02, 0x30, 0x44, 0x31, 0x20, 0x30, 0x1e, 0x06,
    0x0a, 0x2b, 0x06, 0x01, 0x04, 0x01, 0x82, 0xa2, 0x7c, 0x01, 0x03, 0x0c, 0x10, 0x43, 0x41, 0x43, 0x41, 0x43, 0x41, 0x43, 0x41,
    0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x31, 0x20, 0x30, 0x1e, 0x06, 0x0a, 0x2b, 0x06, 0x01, 0x04, 0x01, 0x82, 0xa2,
    0x7c, 0x01, 0x05, 0x0c, 0x10, 0x46, 0x41, 0x42, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x44,
    0x30, 0x1e, 0x17, 0x0d, 0x32, 0x30, 0x31, 0x30, 0x31, 0x35, 0x31, 0x34, 0x32, 0x33, 0x34, 0x33, 0x5a, 0x17, 0x0d, 0x34, 0x30,
    0x31, 0x30, 0x31, 0x35, 0x31, 0x34, 0x32, 0x33, 0x34, 0x32, 0x5a, 0x30, 0x44, 0x31, 0x20, 0x30, 0x1e, 0x06, 0x0a, 0x2b, 0x06,
    0x01, 0x04, 0x01, 0x82, 0xa2, 0x7c, 0x01, 0x01, 0x0c, 0x10, 0x44, 0x45, 0x44, 0x45, 0x44, 0x45, 0x44, 0x45, 0x30, 0x30, 0x30,
    0x32, 0x30, 0x30, 0x30, 0x37, 0x31, 0x20, 0x30, 0x1e, 0x06, 0x0a, 0x2b, 0x06, 0x01, 0x04, 0x01, 0x82, 0xa2, 0x7c, 0x01, 0x05,
    0x0c, 0x10, 0x46, 0x41, 0x42, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x44, 0x30, 0x59, 0x30,
    0x13, 0x06, 0x07, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x02, 0x01, 0x06, 0x08, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x03, 0x01, 0x07, 0x03,
    0x42, 0x00, 0x04, 0xf1, 0x1b, 0x05, 0x37, 0xf3, 0x73, 0x5c, 0xdc, 0xfa, 0xc5, 0x86, 0x15, 0xdd, 0x1b, 0x13, 0x4a, 0x83, 0x85,
    0xa4, 0x75, 0x15, 0x58, 0xfb, 0xd1, 0xfe, 0xd2, 0x55, 0x93, 0x35, 0xd0, 0xc2, 0x42, 0x6f, 0x60, 0x08, 0xf6, 0x05, 0x01, 0xf6,
    0x44, 0xa2, 0x0a, 0x8c, 0xf9, 0xc4, 0x1e, 0x82, 0x8c, 0x38, 0xa5, 0x6f, 0x56, 0x88, 0xd1, 0xfa, 0xaf, 0xd2, 0x8b, 0x21, 0x87,
    0xa8, 0xf4, 0x2e, 0x74, 0xa3, 0x81, 0xc2, 0x30, 0x81, 0xbf, 0x30, 0x0c, 0x06, 0x03, 0x55, 0x1d, 0x13, 0x01, 0x01, 0xff, 0x04,
    0x02, 0x30, 0x00, 0x30, 0x0e, 0x06, 0x03, 0x55, 0x1d, 0x0f, 0x01, 0x01, 0xff, 0x04, 0x04, 0x03, 0x02, 0x07, 0x80, 0x30, 0x20,
    0x06, 0x03, 0x55, 0x1d, 0x25, 0x01, 0x01, 0xff, 0x04, 0x16, 0x30, 0x14, 0x06, 0x08, 0x2b, 0x06, 0x01, 0x05, 0x05, 0x07, 0x03,
    0x02, 0x06, 0x08, 0x2b, 0x06, 0x01, 0x05, 0x05, 0x07, 0x03, 0x01, 0x30, 0x1d, 0x06, 0x03, 0x55, 0x1d, 0x0e, 0x04, 0x16, 0x04,
    0x14, 0xcb, 0x58, 0x71, 0xe3, 0xad, 0x6d, 0xab, 0x0d, 0xbf, 0x29, 0xa5, 0x3c, 0xaa, 0x5b, 0x99, 0x1e, 0x10, 0xbe, 0x71, 0x98,
    0x30, 0x1f, 0x06, 0x03, 0x55, 0x1d, 0x23, 0x04, 0x18, 0x30, 0x16, 0x80, 0x14, 0xcf, 0x42, 0xbc, 0xf8, 0xdf, 0x48, 0x09, 0xd9,
    0x26, 0x6f, 0x23, 0x15, 0x5a, 0x16, 0xb0, 0x7f, 0x04, 0xbb, 0x3d, 0x84, 0x30, 0x1b, 0x06, 0x03, 0x55, 0x1d, 0x11, 0x01, 0x01,
    0xff, 0x04, 0x11, 0x30, 0x0f, 0x81, 0x0d, 0x74, 0x65, 0x73, 0x74, 0x40, 0x63, 0x68, 0x69, 0x70, 0x2e, 0x6f, 0x72, 0x67, 0x30,
    0x20, 0x06, 0x08, 0x2b, 0x06, 0x01, 0x05, 0x05, 0x07, 0x01, 0x01, 0x04, 0x14, 0x30, 0x12, 0x30, 0x10, 0x06, 0x08, 0x2b, 0x06,
    0x01, 0x05, 0x05, 0x07, 0x30, 0x01, 0x86, 0x04, 0x74, 0x65, 0x73, 0x74, 0x30, 0x0a, 0x06, 0x08, 0x2a, 0x86, 0x48, 0xce, 0x3d,
    0x04, 0x03, 0x02, 0x03, 0x49, 0x00, 0x30, 0x46, 0x02, 0x21, 0x00, 0xf1, 0x10, 0x28, 0xaa, 0x62, 0xe4, 0xe9, 0xcd, 0xab, 0xab,
    0xc5, 0x6c, 0x79, 0xc4, 0x5c, 0x4f, 0x04, 0xad, 0xc8, 0x03, 0x37, 0x68, 0x4c, 0xec, 0x78, 0xdc, 0x86, 0x0c, 0x1b, 0xe8, 0x95,
    0xd2, 0x02, 0x21, 0x00, 0x8c, 0x3b, 0x50, 0x55, 0x63, 0xef, 0x99, 0xb2, 0x98, 0x2f, 0x7b, 0xea, 0x03, 0xf3, 0x21, 0x56, 0xec,
    0x98, 0xd0, 0xe5, 0xb8, 0xbf, 0xd1, 0x45, 0x52, 0x04, 0x52, 0xc6, 0x2a, 0x63, 0xc9, 0xb2,
};

extern const uint32_t sTestCert_Node02_07_DER_Len = sizeof(sTestCert_Node02_07_DER);

extern const uint8_t sTestCert_Node02_07_PublicKey[] = {
    0x04, 0xf1, 0x1b, 0x05, 0x37, 0xf3, 0x73, 0x5c, 0xdc, 0xfa, 0xc5, 0x86, 0x15, 0xdd, 0x1b, 0x13, 0x4a,
    0x83, 0x85, 0xa4, 0x75, 0x15, 0x58, 0xfb, 0xd1, 0xfe, 0xd2, 0x55, 0x93, 0x35, 0xd0, 0xc2, 0x42, 0x6f,
    0x60, 0x08, 0xf6, 0x05, 0x01, 0xf6, 0x44, 0xa2, 0x0a, 0x8c, 0xf9, 0xc4, 0x1e, 0x82, 0x8c, 0x38, 0xa5,
    0x6f, 0x56, 0x88, 0xd1, 0xfa, 0xaf, 0xd2, 0x8b, 0x21, 0x87, 0xa8, 0xf4, 0x2e, 0x74,
};

extern const uint8_t sTestCert_Node02_07_PublicKey_Len = sizeof(sTestCert_Node02_07_PublicKey);

extern const uint8_t sTestCert_Node02_07_PrivateKey[] = {
    0x4d, 0xaf, 0x14, 0x7b, 0x94, 0x9a, 0x5e, 0x6c, 0xd2, 0xc6, 0xd7, 0xaa, 0x74, 0xa6, 0x8a, 0x51,
    0x30, 0xa5, 0x5f, 0xfc, 0x69, 0x59, 0x9c, 0xd3, 0x83, 0xc0, 0xe8, 0xad, 0xd9, 0xa6, 0x07, 0xca,
};

extern const uint8_t sTestCert_Node02_07_PrivateKey_Len = sizeof(sTestCert_Node02_07_PrivateKey);

extern const uint8_t sTestCert_Node02_07_SubjectKeyId[] = {
    0xCB, 0x58, 0x71, 0xE3, 0xAD, 0x6D, 0xAB, 0x0D, 0xBF, 0x29, 0xA5, 0x3C, 0xAA, 0x5B, 0x99, 0x1E, 0x10, 0xBE, 0x71, 0x98,
};

extern const uint8_t sTestCert_Node02_07_SubjectKeyId_Len = sizeof(sTestCert_Node02_07_SubjectKeyId);

} // namespace TestCerts
} // namespace chip
